capacitor-native-video-compressor 1.1.1 → 1.1.3

package/README.md

@@ -226,7 +226,9 @@ The `quality` parameter determines the output resolution and compression ratio.
 * [`compressVideo(...)`](#compressvideo)
 * [`cancel(...)`](#cancel)
 * [`initialize()`](#initialize)
+* [`finishUpload(...)`](#finishupload)
 * [`addListener('onProgress', ...)`](#addlisteneronprogress-)
+* [`addListener('onCancelRequested', ...)`](#addlisteneroncancelrequested-)
 * [Interfaces](#interfaces)
 
 </docgen-index>
@@ -282,6 +284,24 @@ initialize() => Promise<{ success: boolean; message?: string; }>
 --------------------
 
 
+### finishUpload(...)
+
+```typescript
+finishUpload(options: { jobId: string; }) => Promise<void>
+```
+
+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.
+
+| Param         | Type                            |
+| ------------- | ------------------------------- |
+| **`options`** | <code>{ jobId: string; }</code> |
+
+--------------------
+
+
 ### addListener('onProgress', ...)
 
 ```typescript
@@ -298,6 +318,29 @@ 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 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".
+
+| Param              | Type                             |
+| ------------------ | -------------------------------- |
+| **`eventName`**    | <code>'onCancelRequested'</code> |
+| **`listenerFunc`** | <code>() =&gt; void</code>       |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+--------------------
+
+
 ### Interfaces
 
 
@@ -311,12 +354,13 @@ addListener(eventName: 'onProgress', listenerFunc: (info: { status: string; perc
 
 #### 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: 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. |
 
 
 #### CancelResult

package/android/src/main/AndroidManifest.xml

@@ -1,14 +1,17 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <!-- mediaProcessing chỉ tồn tại từ API 35. Khai kèm dataSync để máy API 34
-         trở xuống vẫn có một type hợp lệ - service chọn type theo SDK_INT lúc chạy. -->
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROCESSING" />
+    <!-- Chỉ dataSync, không khai mediaProcessing.
+         Hai type nghĩa là hai quyền phải biện minh riêng trong Play Console với
+         cùng một video demo, và mediaProcessing khó thuyết phục hơn hẳn. dataSync
+         phủ được cả hai pha: nén rồi tải lên là một thao tác đồng bộ dữ liệu liên
+         tục do user khởi tạo - đúng ví dụ "upload photo to the cloud" mà policy nêu. -->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application>
         <service
             android:name="com.atomic.videocompressor.VideoCompressionService"
-            android:foregroundServiceType="mediaProcessing|dataSync"
+            android:foregroundServiceType="dataSync"
             android:exported="false" />
     </application>
 </manifest>

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

@@ -16,6 +16,7 @@ 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;
 
@@ -30,9 +31,52 @@ 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.
+     */
+    private static WeakReference<NativeVideoCompressorPlugin> active = new WeakReference<>(null);
+
     /** 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
@@ -73,6 +117,15 @@ public class NativeVideoCompressorPlugin extends Plugin {
         call.resolve(ret);
     }
 
+    @PluginMethod
+    public void finishUpload(PluginCall call) {
+        String jobId = call.getString("jobId");
+        if (jobId != null) {
+            sendToService(VideoCompressionService.ACTION_FINISH, jobId);
+        }
+        call.resolve();
+    }
+
     @PluginMethod
     public void compressVideo(PluginCall call) {
         String sourcePath = call.getString("sourcePath");
@@ -83,6 +136,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
         }
 
         String jobId = call.getString("jobId", "default");
+        boolean holdForUpload = Boolean.TRUE.equals(call.getBoolean("holdForUpload", false));
         synchronized (this) {
             currentJobId = jobId;
         }
@@ -140,7 +194,19 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
         // Khởi động Foreground Service để giữ app luôn sống khi chạy ngầm
         Intent serviceIntent = new Intent(getContext(), VideoCompressionService.class);
-        startServiceCompat(serviceIntent);
+        serviceIntent.setAction(VideoCompressionService.ACTION_START);
+        serviceIntent.putExtra(VideoCompressionService.EXTRA_JOB_ID, jobId);
+        try {
+            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
+                getContext().startForegroundService(serviceIntent);
+            } else {
+                getContext().startService(serviceIntent);
+            }
+        } 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(
@@ -153,6 +219,11 @@ public class NativeVideoCompressorPlugin extends Plugin {
             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");
@@ -162,13 +233,13 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
                 @Override
                 public void onFailure(int i, @NonNull String failureMessage) {
-                    finishJob(serviceIntent);
+                    finishJob(jobId, false);
                     call.reject("Nén thất bại: " + failureMessage);
                 }
 
                 @Override
                 public void onSuccess(int i, long l, @Nullable String s) {
-                    finishJob(serviceIntent);
+                    finishJob(jobId, holdForUpload);
                     // Nén xong, trả kết quả đường dẫn file mới về cho JS
                     JSObject ret = new JSObject();
                     ret.put("success", true);
@@ -185,7 +256,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
                 @Override
                 public void onCancelled(int i) {
-                    finishJob(serviceIntent);
+                    finishJob(jobId, false);
                     // LightCompressor leaves whatever it had already written
                     // behind; without this the cache keeps a partial mp4 per
                     // cancel, and nothing ever collects them.
@@ -198,49 +269,33 @@ public class NativeVideoCompressorPlugin extends Plugin {
         );
     }
 
-    /**
-     * Every terminal callback ends here, so neither is ever left running.
-     *
-     * Dừng bằng một command gửi vào service chứ không phải stopService(): hai lệnh
-     * start/stop đi qua ActivityManager không bảo đảm thứ tự, nên một lần nén lỗi
-     * trong ~90ms (video hỏng) sẽ dừng service trước khi nó kịp startForeground()
-     * và Android giết cả app bằng ForegroundServiceDidNotStartInTimeException.
-     * Command thì dispatch tuần tự trên main thread của service nên luôn đúng thứ tự.
-     */
-    private void finishJob(Intent serviceIntent) {
-        Intent stopIntent = new Intent(getContext(), VideoCompressionService.class);
-        stopIntent.setAction(VideoCompressionService.ACTION_STOP);
-        if (!startServiceCompat(stopIntent)) {
-            // Không gửi được command (hệ thống chặn start) thì service cũng không
-            // còn sống để mà treo - dọn bằng cách cũ cho chắc.
-            try {
-                getContext().stopService(serviceIntent);
-            } catch (Exception e) {
-                Log.w("NativeVideoCompressor", "Could not stop compression service", e);
-            }
-        }
+    /** Every terminal callback ends here, so neither is ever left running. */
+    private void finishJob(String jobId, boolean holdForUpload) {
+        sendToService(
+            holdForUpload ? VideoCompressionService.ACTION_UPLOAD : VideoCompressionService.ACTION_FINISH,
+            jobId
+        );
         synchronized (this) {
             currentJobId = null;
         }
     }
 
-    /** @return false khi hệ thống từ chối cả hai cách khởi động service. */
-    private boolean startServiceCompat(Intent intent) {
+    /**
+     * 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) {
         try {
-            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
-                getContext().startForegroundService(intent);
-            } else {
-                getContext().startService(intent);
-            }
-            return true;
+            Intent intent = new Intent(getContext(), VideoCompressionService.class);
+            intent.setAction(action);
+            intent.putExtra(VideoCompressionService.EXTRA_JOB_ID, jobId);
+            getContext().startService(intent);
         } catch (Exception e) {
-            try {
-                getContext().startService(intent);
-                return true;
-            } catch (Exception inner) {
-                Log.w("NativeVideoCompressor", "Could not start compression service", inner);
-                return false;
-            }
+            Log.w("NativeVideoCompressor", "Could not send " + action + " to service", e);
         }
     }