capacitor-native-video-compressor 1.1.0 → 1.1.2

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:
@@ -196,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>
@@ -252,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
@@ -268,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
 
 
@@ -281,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,6 +1,12 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <!-- 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

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,14 +194,18 @@ 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 {
+        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);
-            } catch (Exception e) {
+            } else {
                 getContext().startService(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)
@@ -161,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");
@@ -170,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);
@@ -193,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.
@@ -207,13 +270,35 @@ public class NativeVideoCompressorPlugin extends Plugin {
     }
 
     /** Every terminal callback ends here, so neither is ever left running. */
-    private void finishJob(Intent serviceIntent) {
-        getContext().stopService(serviceIntent);
+    private void finishJob(String jobId, boolean holdForUpload) {
+        sendToService(
+            holdForUpload ? VideoCompressionService.ACTION_UPLOAD : VideoCompressionService.ACTION_FINISH,
+            jobId
+        );
         synchronized (this) {
             currentJobId = null;
         }
     }
 
+    /**
+     * 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 {
+            Intent intent = new Intent(getContext(), VideoCompressionService.class);
+            intent.setAction(action);
+            intent.putExtra(VideoCompressionService.EXTRA_JOB_ID, jobId);
+            getContext().startService(intent);
+        } catch (Exception e) {
+            Log.w("NativeVideoCompressor", "Could not send " + action + " to service", e);
+        }
+    }
+
     /** 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

@@ -3,61 +3,317 @@ 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";
+
+    /**
+     * 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".
+     *
+     * 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.
+     *
+     * 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.
+     */
+    @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 khi bạn dùng ứng dụng khác");
+        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) {
+        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 (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;
+    }
+
+    /**
+     * 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";
+        }
+
+        String text;
+        if (indeterminate) {
+            text = "Đang tải lên, sẽ tiếp tục khi bạn dùng ứng dụng khác";
+        } else {
+            text = shown.percent + "% - "
+                + (shown.phase == Phase.UPLOADING ? "đang tải lên" : "đang nén")
+                + ", sẽ tiếp tục khi bạn dùng ứng dụng khác";
+        }
+
         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();
 
-        // 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);
+            ServiceCompat.startForeground(
+                this, NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            );
+            inForeground = true;
         } catch (Exception e) {
-            e.printStackTrace();
+            // 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);
         }
+    }
 
-        return START_NOT_STICKY;
+    /**
+     * 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;
     }
 }