capacitor-native-video-compressor 1.0.5 → 1.1.1

package/README.md

@@ -35,6 +35,36 @@ If you are reading videos from external storage, ensure you have the appropriate
 <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
 ```
 
+#### JitPack repository (required)
+
+The Android implementation depends on `LightCompressor`, which is published on JitPack.
+A plugin's own `repositories` block does not propagate to the consuming app, so you must
+add JitPack to your app's `android/build.gradle` — otherwise the build fails with
+`Could not find com.github.AbedElazizShe:LightCompressor`:
+
+```gradle
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+        maven { url 'https://jitpack.io' }
+    }
+}
+```
+
+#### compileSdk 35+ (required)
+
+The compression foreground service declares `android:foregroundServiceType="mediaProcessing|dataSync"`.
+`mediaProcessing` exists only from **API 35 (Android 15)**, so your app must build with
+`compileSdkVersion` 35 or higher.
+
+At runtime the service picks the type by API level: `mediaProcessing` on API 35+,
+`dataSync` on API 29-34. Both types and both permissions are declared, so the plugin
+runs correctly on Android 10 through 15+. Passing only `mediaProcessing` on API 34
+makes the system read the type as unknown and `startForeground()` throws
+`InvalidForegroundServiceTypeException` - the service never reaches the foreground
+and compression is killed as soon as the user leaves the app.
+
 ## Web Configuration (Required)
 
 To use video compression on the Web platform, `FFmpeg.wasm` requires `SharedArrayBuffer` to function properly. You must configure your web server/framework to serve these specific HTTP headers:

package/android/src/main/AndroidManifest.xml

@@ -1,11 +1,14 @@
 <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" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
 
     <application>
         <service
             android:name="com.atomic.videocompressor.VideoCompressionService"
-            android:foregroundServiceType="dataSync"
+            android:foregroundServiceType="mediaProcessing|dataSync"
             android:exported="false" />
     </application>
 </manifest>

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

@@ -140,15 +140,7 @@ 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);
-        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
-            try {
-                getContext().startForegroundService(serviceIntent);
-            } catch (Exception e) {
-                getContext().startService(serviceIntent);
-            }
-        } else {
-            getContext().startService(serviceIntent);
-        }
+        startServiceCompat(serviceIntent);
 
         // 4. Bắt đầu nén (Đã cập nhật List Uri và int index)
         VideoCompressor.start(
@@ -206,14 +198,52 @@ public class NativeVideoCompressorPlugin extends Plugin {
         );
     }
 
-    /** Every terminal callback ends here, so neither is ever left running. */
+    /**
+     * 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) {
-        getContext().stopService(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);
+            }
+        }
         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) {
+        try {
+            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
+                getContext().startForegroundService(intent);
+            } else {
+                getContext().startService(intent);
+            }
+            return true;
+        } catch (Exception e) {
+            try {
+                getContext().startService(intent);
+                return true;
+            } catch (Exception inner) {
+                Log.w("NativeVideoCompressor", "Could not start compression service", inner);
+                return false;
+            }
+        }
+    }
+
     /** Best-effort: a partial file left in the cache is not worth failing over. */
     private void deleteOutput(String fileName) {
         try {

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

@@ -5,16 +5,35 @@ import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.app.Service;
 import android.content.Intent;
+import android.content.pm.ServiceInfo;
 import android.os.Build;
 import android.os.IBinder;
+import android.util.Log;
 import androidx.annotation.Nullable;
 import androidx.core.app.NotificationCompat;
 
 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;
 
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * 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.
+     */
+    static final String ACTION_STOP = "com.atomic.videocompressor.action.STOP";
+
     @Override
     public void onCreate() {
         super.onCreate();
@@ -23,6 +42,17 @@ public class VideoCompressionService extends Service {
 
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
+        enterForeground();
+
+        if (intent != null && ACTION_STOP.equals(intent.getAction())) {
+            stopForegroundCompat();
+            stopSelf();
+        }
+
+        return START_NOT_STICKY;
+    }
+
+    private void enterForeground() {
         Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
             .setContentTitle("Đang nén video")
             .setContentText("Tiến trình đang chạy ngầm...")
@@ -30,15 +60,33 @@ public class VideoCompressionService extends Service {
             .setPriority(NotificationCompat.PRIORITY_LOW)
             .build();
 
-        // Check for Android 14+ specific foreground service typing requirements if compiled against API 34+
-        // In this case, we rely on the manifest declaration for dataSync.
         try {
-            startForeground(NOTIFICATION_ID, notification);
+            // 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);
+            }
         } catch (Exception e) {
-            e.printStackTrace();
+            // 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);
         }
+    }
 
-        return START_NOT_STICKY;
+    private void stopForegroundCompat() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            stopForeground(STOP_FOREGROUND_REMOVE);
+        } else {
+            stopForeground(true);
+        }
     }
 
     @Nullable

package/dist/esm/web.d.ts

@@ -3,25 +3,31 @@ import type { NativeVideoCompressorPlugin, CompressOptions, CompressResult, Canc
 export declare class NativeVideoCompressorWeb extends WebPlugin implements NativeVideoCompressorPlugin {
     private ffmpeg;
     private isLoaded;
+    /** The mediabunny conversion running now, so `cancel()` can abort it. */
+    private activeConversion;
     /** The job `compressVideo` is running right now, for `cancel({ jobId })`. */
     private currentJobId;
     private cancelRequested;
-    private loadFFmpeg;
-    /**
-     * Kill the worker outright — there is no gentler option.
-     *
-     * `ffmpeg.exec()` runs *synchronously* inside the worker (see
-     * @ffmpeg/ffmpeg's worker.js: `ffmpeg.exec(...args)` is not awaited), so the
-     * worker never reaches a message poll while encoding. The AbortSignal that
-     * `exec()` accepts only rejects the main-thread promise; the encode keeps
-     * burning CPU behind it. `worker.terminate()` is what actually stops it.
-     *
-     * The cost is the loaded core, which is why the core URLs are cached above.
-     */
-    cancel(options?: CancelOptions): Promise<CancelResult>;
     initialize(): Promise<{
         success: boolean;
         message?: string;
     }>;
     compressVideo(options: CompressOptions): Promise<CompressResult>;
+    /**
+     * Kill whichever engine is mid-compress. Only one is ever active at a time,
+     * so acting on both is safe.
+     *
+     * WebCodecs: `conversion.cancel()` makes the in-flight `execute()` reject
+     * with `ConversionCanceledError`, surfaced as a `CancelledError` below.
+     * ffmpeg: `exec()` runs synchronously inside the worker and never reaches a
+     * message poll while encoding, so `worker.terminate()` is the only way to
+     * stop it — its cost is the loaded core, which is why the core URLs are
+     * cached above.
+     */
+    cancel(options?: CancelOptions): Promise<CancelResult>;
+    private fetchSourceBlob;
+    private canUseWebCodecs;
+    private compressWithWebCodecs;
+    private loadFFmpeg;
+    private compressWithFfmpeg;
 }