capacitor-native-video-compressor 1.1.1 → 1.1.3

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

@@ -3,109 +3,326 @@ package com.atomic.videocompressor;
 import android.app.Notification;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
+import android.app.PendingIntent;
 import android.app.Service;
 import android.content.Intent;
 import android.content.pm.ServiceInfo;
 import android.os.Build;
+import android.os.Handler;
 import android.os.IBinder;
+import android.os.Looper;
+import android.os.SystemClock;
 import android.util.Log;
 import androidx.annotation.Nullable;
 import androidx.core.app.NotificationCompat;
+import androidx.core.app.ServiceCompat;
+import java.util.LinkedHashMap;
+import java.util.Map;
 
+/**
+ * Giữ tiến trình nén + upload sống khi user rời app.
+ *
+ * Mọi thứ trong đây phải đáp ứng được 5 tiêu chí foreground service của Google
+ * Play, vì bản thiếu chúng (1.1.0) đã bị từ chối ở version code 29:
+ *
+ *  - user perceptible  -> notification có progress thật, cập nhật theo % nén
+ *    và theo pha (nén / tải lên), chứ không phải một dòng chữ tĩnh
+ *  - stoppable by user -> action "Huỷ" ngay trên notification, vì khi user đã
+ *    rời app thì UI trong app không còn với tới được
+ *  - runs only as long as necessary -> watchdog tự tắt khi không còn ai báo
+ *    tiến trình, để một lần JS chết giữa đường không để lại FGS chạy vô hạn
+ */
 public class VideoCompressionService extends Service {
 
     private static final String TAG = "VideoCompressionService";
     private static final String CHANNEL_ID = "VideoCompressionChannel";
     private static final int NOTIFICATION_ID = 1001;
 
+    static final String ACTION_START = "com.atomic.videocompressor.START";
+    static final String ACTION_UPLOAD = "com.atomic.videocompressor.UPLOAD";
+    static final String ACTION_FINISH = "com.atomic.videocompressor.FINISH";
+    /** Do chính user bấm từ notification. */
+    static final String ACTION_CANCEL = "com.atomic.videocompressor.CANCEL";
+
+    static final String EXTRA_JOB_ID = "jobId";
+    static final String EXTRA_PERCENT = "percent";
+
     /**
-     * Lệnh kết thúc, do plugin gửi qua chính hàng đợi command của service thay vì
-     * gọi stopService() từ ngoài.
+     * Không nhận được update nào trong khoảng này thì coi như phía gọi đã chết
+     * (WebView bị kill, hoặc một exception thoát ra ngoài nhánh finishUpload) và
+     * tự dừng. Không có nó, `jobs` không bao giờ rỗng và service chạy mãi với
+     * một notification treo - đúng thứ khiến Play đánh trượt tiêu chí "runs only
+     * for as long as necessary".
      *
-     * stopService() và startForegroundService() là hai lệnh độc lập đi qua
-     * ActivityManager, nên không có gì bảo đảm thứ tự: nén lỗi trong vòng ~90ms
-     * (video hỏng) thì lệnh stop tới trước khi onStartCommand kịp chạy, AMS thấy
-     * "Bringing down service while still waiting for start foreground" và ném
-     * ForegroundServiceDidNotStartInTimeException - chết cả app.
+     * Chọn 15 phút: dài hơn mọi khoảng lặng hợp lệ (upload một video đã nén trên
+     * mạng chậm, hoặc pha nén chưa kịp bắn progress đầu tiên), ngắn hơn nhiều so
+     * với mức mà user kịp nhận ra có gì đó treo.
+     */
+    private static final long WATCHDOG_MS = 15 * 60 * 1000L;
+
+    /** Đừng vẽ lại notification mỗi tick progress của LightCompressor. */
+    private static final long MIN_REDRAW_INTERVAL_MS = 500L;
+
+    private enum Phase { COMPRESSING, UPLOADING }
+
+    private static final class Job {
+        Phase phase = Phase.COMPRESSING;
+        int percent = 0;
+    }
+
+    /** LinkedHashMap: notification một job hiển thị đúng job đã bắt đầu trước. */
+    private final Map<String, Job> jobs = new LinkedHashMap<>();
+
+    private final Handler handler = new Handler(Looper.getMainLooper());
+    private final Runnable watchdog = this::onWatchdogFired;
+
+    private long lastRedrawUptime = 0;
+    private boolean inForeground = false;
+
+    /**
+     * Instance đang sống, để plugin đẩy % vào mà không phải gửi một Intent cho
+     * mỗi tick.
      *
-     * Command của service thì được dispatch tuần tự trên main thread, nên STOP
-     * luôn chạy sau START. Mỗi onStartCommand đều gọi startForeground() trước,
-     * kể cả nhánh STOP, để mọi startForegroundService() đang treo đều được đáp ứng.
+     * volatile vì được đọc từ thread nền: LightCompressor gọi onProgress thẳng
+     * từ coroutine encoder (Dispatchers.Default), không hop về main - đã kiểm
+     * bằng bytecode, onProgressChanged gọi listener trực tiếp không qua
+     * withContext. Thiếu volatile thì thread đó có thể đọc phải một tham chiếu
+     * cũ của service đã destroy.
      */
-    static final String ACTION_STOP = "com.atomic.videocompressor.action.STOP";
+    @Nullable
+    private static volatile VideoCompressionService instance = null;
 
     @Override
     public void onCreate() {
         super.onCreate();
-        createNotificationChannel();
+        instance = this;
+        NotificationChannel channel = new NotificationChannel(
+            CHANNEL_ID, "Xử lý và tải video lên", NotificationManager.IMPORTANCE_LOW
+        );
+        channel.setDescription("Tiến trình nén và tải video lên");
+        NotificationManager manager = getSystemService(NotificationManager.class);
+        if (manager != null) manager.createNotificationChannel(channel);
+    }
+
+    @Override
+    public void onDestroy() {
+        handler.removeCallbacks(watchdog);
+        if (instance == this) instance = null;
+        super.onDestroy();
+    }
+
+    /**
+     * Cập nhật tiến độ nén. Gọi được từ thread bất kỳ.
+     *
+     * No-op khi service chưa/không còn sống: progress là thông tin trang trí,
+     * không đáng để dựng lại một foreground service đã tắt.
+     */
+    static void publishProgress(String jobId, int percent) {
+        VideoCompressionService service = instance;
+        if (service == null) return;
+        // Chuyển về main thread: lời gọi tới đây nằm trên thread encoder của
+        // LightCompressor, còn jobs/handler/notification đều chỉ được chạm từ
+        // main. Không post thì LinkedHashMap bị sửa đồng thời với onStartCommand.
+        service.handler.post(() -> service.applyProgress(jobId, percent));
+    }
+
+    private void applyProgress(String jobId, int percent) {
+        Job job = jobs.get(jobId);
+        if (job == null) return;
+
+        int clamped = Math.max(0, Math.min(100, percent));
+        // Mỗi update đều gia hạn watchdog, kể cả khi bỏ qua việc vẽ lại:
+        // throttle chỉ để tiết kiệm vẽ, không phải dấu hiệu job đã chết.
+        armWatchdog();
+        if (job.percent == clamped) return;
+        job.percent = clamped;
+
+        long now = SystemClock.uptimeMillis();
+        if (now - lastRedrawUptime < MIN_REDRAW_INTERVAL_MS && clamped < 100) return;
+        lastRedrawUptime = now;
+        render();
     }
 
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
-        enterForeground();
+        if (intent == null) {
+            // START_NOT_STICKY nên chỉ xảy ra khi hệ thống restart service;
+            // không có job nào để phục hồi, dừng cho sạch.
+            stopEverything();
+            return START_NOT_STICKY;
+        }
+
+        String action = intent.getAction();
 
-        if (intent != null && ACTION_STOP.equals(intent.getAction())) {
-            stopForegroundCompat();
-            stopSelf();
+        if (ACTION_CANCEL.equals(action)) {
+            // Notification là thứ duy nhất user còn thấy khi đã rời app, nên
+            // nút này huỷ tất cả: không có UI nào ở đây để chọn từng job.
+            NativeVideoCompressorPlugin.cancelAllFromNotification();
+            stopEverything();
+            return START_NOT_STICKY;
         }
 
+        String jobId = intent.getStringExtra(EXTRA_JOB_ID);
+        if (jobId == null) return START_NOT_STICKY;
+
+        if (ACTION_START.equals(action)) {
+            jobs.put(jobId, new Job());
+        } else if (ACTION_UPLOAD.equals(action)) {
+            Job job = jobs.get(jobId);
+            if (job != null) {
+                job.phase = Phase.UPLOADING;
+                // Pha upload không có % nào bắn về, nên thanh progress chuyển
+                // sang indeterminate thay vì đứng im ở con số của pha nén.
+                job.percent = -1;
+            }
+        } else if (ACTION_FINISH.equals(action)) {
+            jobs.remove(jobId);
+        }
+
+        if (jobs.isEmpty()) {
+            stopEverything();
+            return START_NOT_STICKY;
+        }
+
+        armWatchdog();
+        lastRedrawUptime = SystemClock.uptimeMillis();
+        render();
         return START_NOT_STICKY;
     }
 
-    private void enterForeground() {
+    /**
+     * startForeground() phải được gọi trong mọi nhánh của onStartCommand đến
+     * được từ startForegroundService(), kể cả nhánh dừng ngay: nếu không,
+     * Android giết cả app bằng ForegroundServiceDidNotStartInTimeException.
+     */
+    private void render() {
+        Job shown = jobs.values().iterator().next();
+        int running = jobs.size();
+        boolean indeterminate = shown.percent < 0;
+
+        String title;
+        if (running > 1) {
+            title = "Đang xử lý " + running + " video";
+        } else {
+            title = shown.phase == Phase.UPLOADING ? "Đang tải video lên" : "Đang nén video";
+        }
+
+        // Hai pha nói hai điều khác nhau, vì chúng chạy ở hai nơi khác nhau.
+        //
+        // Nén chạy ở native trong chính service này nên vẫn chạy khi app
+        // xuống nền. Upload thì chạy bằng JS trong webview, nên nó đứng lại
+        // và chỉ tiếp tục khi app trở lại foreground - đo được: nén xong là
+        // mọi hoạt động mạng dừng hẳn cho tới khi watchdog tự dừng service
+        // sau 15 phút. Vì vậy pha upload phải nói rõ việc người dùng cần làm.
+        String text;
+        if (shown.phase == Phase.UPLOADING) {
+            text = indeterminate
+                ? "Mở lại ứng dụng để hoàn tất tải lên"
+                : shown.percent + "% - mở lại ứng dụng để hoàn tất tải lên";
+        } else {
+            text = indeterminate
+                ? "Đang nén video"
+                : shown.percent + "% - đang nén";
+        }
+
         Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle("Đang nén video")
-            .setContentText("Tiến trình đang chạy ngầm...")
-            .setSmallIcon(android.R.drawable.ic_popup_sync)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setSmallIcon(resolveSmallIcon())
+            .setProgress(100, indeterminate ? 0 : shown.percent, indeterminate)
+            .setOngoing(true)
+            // Không có nó, mỗi lần vẽ lại progress là một lần notification
+            // nhảy lên đầu danh sách và rung máy.
+            .setOnlyAlertOnce(true)
             .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setContentIntent(buildOpenAppIntent())
+            .addAction(0, "Huỷ", buildCancelIntent())
             .build();
 
         try {
-            // Google Play đòi mediaProcessing cho tác vụ nén video, nhưng type đó chỉ có
-            // từ API 35. Trên API 34 hệ thống đọc manifest ra "type unknown",
-            // startForeground() ném InvalidForegroundServiceTypeException và service
-            // không bao giờ vào foreground - nén bị huỷ ngay khi user rời app. Nên chọn
-            // type lúc chạy; AndroidManifest khai cả hai nên type nào cũng hợp lệ.
-            if (Build.VERSION.SDK_INT >= 35) {
-                startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROCESSING);
-            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
-            } else {
-                // Trước API 29 chưa có khái niệm foreground service type.
-                startForeground(NOTIFICATION_ID, notification);
-            }
+            ServiceCompat.startForeground(
+                this, NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            );
+            inForeground = true;
         } catch (Exception e) {
-            // Nuốt lỗi ở đây để không giết app, nhưng phải log ra TAG riêng: nếu không,
-            // service chạy nền âm thầm và không ai biết cho tới khi user báo nén hỏng.
-            Log.e(TAG, "startForeground thất bại - service sẽ chạy nền, nén có thể bị huỷ", e);
+            // Nuốt để không giết app, nhưng log: service chạy nền âm thầm thì
+            // nén vẫn bị huỷ ngay khi user rời app và không ai biết tại sao.
+            Log.e(TAG, "startForeground thất bại - tiến trình có thể bị huỷ khi rời app", e);
         }
     }
 
-    private void stopForegroundCompat() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-            stopForeground(STOP_FOREGROUND_REMOVE);
-        } else {
-            stopForeground(true);
-        }
+    /**
+     * Icon brand của app nếu có drawable `ic_stat_video_compress`, nếu không thì
+     * icon hệ thống. Notification mang icon hệ thống trông như của Android chứ
+     * không phải của app - trên video demo gửi Play, đó là một điểm trừ.
+     */
+    private int resolveSmallIcon() {
+        int id = getResources().getIdentifier("ic_stat_video_compress", "drawable", getPackageName());
+        return id != 0 ? id : android.R.drawable.ic_popup_sync;
+    }
+
+    private PendingIntent buildCancelIntent() {
+        Intent intent = new Intent(this, VideoCompressionService.class).setAction(ACTION_CANCEL);
+        return PendingIntent.getService(
+            this, 1, intent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
     }
 
+    /** Bấm vào notification thì quay lại app, chứ không phải không có gì xảy ra. */
     @Nullable
+    private PendingIntent buildOpenAppIntent() {
+        Intent launch = getPackageManager().getLaunchIntentForPackage(getPackageName());
+        if (launch == null) return null;
+        launch.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        return PendingIntent.getActivity(
+            this, 2, launch, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
+    }
+
+    private void armWatchdog() {
+        handler.removeCallbacks(watchdog);
+        handler.postDelayed(watchdog, WATCHDOG_MS);
+    }
+
+    private void onWatchdogFired() {
+        Log.w(TAG, "Không có tiến trình nào trong " + (WATCHDOG_MS / 60000) + " phút - tự dừng");
+        NativeVideoCompressorPlugin.cancelAllFromNotification();
+        stopEverything();
+    }
+
+    /**
+     * Android 15+ giới hạn dataSync tổng 6 giờ/24 giờ rồi gọi onTimeout. Phải
+     * dừng trong vài giây, nếu không app ăn ANR. destini-web đặt minSdk 35 nên
+     * mọi thiết bị đều ở trong diện này.
+     */
     @Override
-    public IBinder onBind(Intent intent) {
-        return null;
+    public void onTimeout(int startId, int fgsType) {
+        Log.w(TAG, "Hệ thống hết hạn foreground service (type " + fgsType + ") - dừng ngay");
+        NativeVideoCompressorPlugin.cancelAllFromNotification();
+        stopEverything();
     }
 
-    private void createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            NotificationChannel serviceChannel = new NotificationChannel(
-                CHANNEL_ID,
-                "Video Compression Service Channel",
-                NotificationManager.IMPORTANCE_LOW
-            );
-            NotificationManager manager = getSystemService(NotificationManager.class);
-            if (manager != null) {
-                manager.createNotificationChannel(serviceChannel);
-            }
+    /** Overload của API 34, giữ lại cho thiết bị chạy Android 14. */
+    @Override
+    public void onTimeout(int startId) {
+        Log.w(TAG, "Hệ thống hết hạn foreground service - dừng ngay");
+        NativeVideoCompressorPlugin.cancelAllFromNotification();
+        stopEverything();
+    }
+
+    private void stopEverything() {
+        handler.removeCallbacks(watchdog);
+        jobs.clear();
+        if (inForeground) {
+            ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE);
+            inForeground = false;
         }
+        stopSelf();
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
     }
 }

package/dist/docs.json

@@ -53,6 +53,22 @@
         "complexTypes": [],
         "slug": "initialize"
       },
+      {
+        "name": "finishUpload",
+        "signature": "(options: { jobId: string; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ jobId: string; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "Báo rằng phần upload đi kèm `holdForUpload` đã xong (thành công hay thất\nbại đều phải gọi) để Android hạ foreground service xuống.\n\nNo-op trên web và iOS.",
+        "complexTypes": [],
+        "slug": "finishupload"
+      },
       {
         "name": "addListener",
         "signature": "(eventName: 'onProgress', listenerFunc: (info: { status: string; percent?: number; }) => void) => Promise<PluginListenerHandle>",
@@ -75,6 +91,29 @@
           "PluginListenerHandle"
         ],
         "slug": "addlisteneronprogress-"
+      },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'onCancelRequested', listenerFunc: () => void) => Promise<PluginListenerHandle>",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "",
+            "type": "'onCancelRequested'"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "",
+            "type": "() => void"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle>",
+        "tags": [],
+        "docs": "Android: user đã bấm \"Huỷ\" trên notification của foreground service.\n\nPha nén được plugin tự huỷ trước khi event này bắn, nhưng pha upload chạy\ntrong JS nên không ai dừng hộ được - caller phải tự abort request đang\nchạy. Bỏ qua event này nghĩa là nút Huỷ không thật sự huỷ, và Play đánh\ntrượt tiêu chí \"can be terminated or stopped by the user\".",
+        "complexTypes": [
+          "PluginListenerHandle"
+        ],
+        "slug": "addlisteneroncancelrequested-"
       }
     ],
     "properties": []
@@ -137,6 +176,13 @@
           "docs": "Names this compress so `cancel({ jobId })` can target it.\n\nEvery platform compresses one video at a time, so cancellation is global\nby nature. Two independent callers in the same app (say a comment queue\nand a notes queue) therefore need a way to say *which* job they mean —\nwithout one, a cancel from either kills whatever the other is running.",
           "complexTypes": [],
           "type": "string | undefined"
+        },
+        {
+          "name": "holdForUpload",
+          "tags": [],
+          "docs": "Android: giữ foreground service sống sau khi nén xong, để phần upload do\nJS chạy tiếp theo không bị hệ thống giết khi user rời app.\n\nBật cờ này là một lời hứa: caller PHẢI gọi {@link NativeVideoCompressorPlugin.finishUpload}\nkhi upload kết thúc, kể cả ở nhánh lỗi. Không gọi thì service chỉ còn\nwatchdog dọn hộ sau 15 phút, và trong 15 phút đó user nhìn thấy một\nnotification nói rằng app đang làm việc trong khi nó không làm gì cả.\n\nKhông có tác dụng trên web và iOS.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -18,6 +18,18 @@ export interface CompressOptions {
      * without one, a cancel from either kills whatever the other is running.
      */
     jobId?: string;
+    /**
+     * Android: giữ foreground service sống sau khi nén xong, để phần upload do
+     * JS chạy tiếp theo không bị hệ thống giết khi user rời app.
+     *
+     * Bật cờ này là một lời hứa: caller PHẢI gọi {@link NativeVideoCompressorPlugin.finishUpload}
+     * khi upload kết thúc, kể cả ở nhánh lỗi. Không gọi thì service chỉ còn
+     * watchdog dọn hộ sau 15 phút, và trong 15 phút đó user nhìn thấy một
+     * notification nói rằng app đang làm việc trong khi nó không làm gì cả.
+     *
+     * Không có tác dụng trên web và iOS.
+     */
+    holdForUpload?: boolean;
 }
 export interface CompressResult {
     success: boolean;
@@ -49,8 +61,26 @@ export interface NativeVideoCompressorPlugin {
         success: boolean;
         message?: string;
     }>;
+    /**
+     * Báo rằng phần upload đi kèm `holdForUpload` đã xong (thành công hay thất
+     * bại đều phải gọi) để Android hạ foreground service xuống.
+     *
+     * No-op trên web và iOS.
+     */
+    finishUpload(options: {
+        jobId: string;
+    }): Promise<void>;
     addListener(eventName: 'onProgress', listenerFunc: (info: {
         status: string;
         percent?: number;
     }) => 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 pha upload chạy
+     * trong JS nên không ai dừng hộ được - caller phải tự abort request đang
+     * chạy. 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".
+     */
+    addListener(eventName: 'onCancelRequested', listenerFunc: () => void): Promise<PluginListenerHandle>;
 }

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\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  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  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","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  /**\n   * Android: giữ foreground service sống sau khi nén xong, để phần upload do\n   * JS chạy tiếp theo không bị hệ thống giết khi user rời app.\n   *\n   * Bật cờ này là một lời hứa: caller PHẢI gọi {@link NativeVideoCompressorPlugin.finishUpload}\n   * khi upload kết thúc, kể cả ở nhánh lỗi. Không gọi thì service chỉ còn\n   * watchdog dọn hộ sau 15 phút, và trong 15 phút đó user nhìn thấy một\n   * notification nói rằng app đang làm việc trong khi nó không làm gì cả.\n   *\n   * Không có tác dụng trên web và iOS.\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  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  initialize(): Promise<{ success: boolean; message?: string }>;\n\n  /**\n   * Báo rằng phần upload đi kèm `holdForUpload` đã xong (thành công hay thất\n   * bại đều phải gọi) để Android hạ foreground service xuống.\n   *\n   * No-op trên web và iOS.\n   */\n  finishUpload(options: { jobId: string }): Promise<void>;\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  /**\n   * Android: user đã bấm \"Huỷ\" trên notification của foreground service.\n   *\n   * Pha nén được plugin tự huỷ trước khi event này bắn, nhưng pha upload chạy\n   * trong JS nên không ai dừng hộ được - caller phải tự abort request đang\n   * chạy. Bỏ qua event này nghĩa là nút Huỷ không thật sự huỷ, và Play đánh\n   * trượt tiêu chí \"can be terminated or stopped by the user\".\n   */\n  addListener(\n    eventName: 'onCancelRequested',\n    listenerFunc: () => void,\n  ): Promise<PluginListenerHandle>;\n}\n"]}

package/dist/esm/web.d.ts

@@ -24,6 +24,11 @@ export declare class NativeVideoCompressorWeb extends WebPlugin implements Nativ
      * stop it — its cost is the loaded core, which is why the core URLs are
      * cached above.
      */
+    /**
+     * Chỉ Android mới có foreground service để mà hạ xuống. Hiện diện ở đây để
+     * caller gọi thẳng, không phải rẽ nhánh theo platform ở mọi call site.
+     */
+    finishUpload(): Promise<void>;
     cancel(options?: CancelOptions): Promise<CancelResult>;
     private fetchSourceBlob;
     private canUseWebCodecs;

package/dist/esm/web.js

@@ -134,6 +134,13 @@ export class NativeVideoCompressorWeb extends WebPlugin {
      * stop it — its cost is the loaded core, which is why the core URLs are
      * cached above.
      */
+    /**
+     * Chỉ Android mới có foreground service để mà hạ xuống. Hiện diện ở đây để
+     * caller gọi thẳng, không phải rẽ nhánh theo platform ở mọi call site.
+     */
+    async finishUpload() {
+        return;
+    }
     async cancel(options) {
         var _a;
         if (!this.currentJobId)