react-native-compressor 1.18.2 → 2.0.0

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/videoHelpers/OutputSurface.kt

@@ -2,6 +2,8 @@ package com.reactnativecompressor.Video.VideoCompressor.video
 
 import android.graphics.SurfaceTexture
 import android.graphics.SurfaceTexture.OnFrameAvailableListener
+import android.os.Handler
+import android.os.HandlerThread
 import android.view.Surface
 
 class OutputSurface : OnFrameAvailableListener {
@@ -12,6 +14,15 @@ class OutputSurface : OnFrameAvailableListener {
     private var mFrameAvailable = false
     private var mTextureRender: TextureRenderer? = null
 
+    // Dedicated thread for SurfaceTexture's onFrameAvailable callback.
+    // Without this, Android delivers the callback on the main UI thread
+    // (because the compression coroutine has no Looper), so awaitNewImage()
+    // stalls whenever the main thread is busy with UI / JS bridge work.
+    // Routing the callback to its own thread removes that contention and
+    // is the single biggest throughput win for the decoder→encoder pipeline.
+    private val mCallbackThread = HandlerThread("CompressorSurfaceTexCb").apply { start() }
+    private val mCallbackHandler = Handler(mCallbackThread.looper)
+
     /**
      * Creates an OutputSurface using the current EGL context. This Surface will be
      * passed to MediaCodec.configure().
@@ -35,7 +46,7 @@ class OutputSurface : OnFrameAvailableListener {
             // causes the native finalizer to run.
             mSurfaceTexture = SurfaceTexture(it.getTextureId())
             mSurfaceTexture?.let { surfaceTexture ->
-                surfaceTexture.setOnFrameAvailableListener(this)
+                surfaceTexture.setOnFrameAvailableListener(this, mCallbackHandler)
                 mSurface = Surface(mSurfaceTexture)
             }
         }
@@ -43,6 +54,13 @@ class OutputSurface : OnFrameAvailableListener {
 
     /**
      * Discards all resources held by this class, notably the EGL context.
+     *
+     * quitSafely() returns immediately; the HandlerThread's native pthread
+     * may still be terminating when callers proceed to tear down MediaCodec.
+     * If the ART sampling profiler walks threads during that window it can
+     * dereference a stale pthread_t and SIGABRT. join(500) blocks until the
+     * thread is fully exited (pthread_join) so the pthread_t is no longer
+     * tracked. Bounded at 500ms to avoid hanging on a pathological looper.
      */
     fun release() {
         mSurface?.release()
@@ -50,6 +68,13 @@ class OutputSurface : OnFrameAvailableListener {
         mTextureRender = null
         mSurface = null
         mSurfaceTexture = null
+
+        mCallbackThread.quitSafely()
+        try {
+            mCallbackThread.join(500)
+        } catch (ignored: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
     }
 
     /**
@@ -63,12 +88,13 @@ class OutputSurface : OnFrameAvailableListener {
      * data is available.
      */
     fun awaitNewImage() {
-        val timeOutMS = 100
+        // 10s timeout to avoid spurious failures under heavy main-thread load.
+        // The callback now arrives on a dedicated thread, so realistic frames
+        // land in <50ms; this bound only catches a stuck pipeline.
+        val timeOutMS = 10_000
         synchronized(mFrameSyncObject) {
             while (!mFrameAvailable) {
                 try {
-                    // Wait for onFrameAvailable() to signal us.  Use a timeout to avoid
-                    // stalling the test if it doesn't arrive.
                     mFrameSyncObject.wait(timeOutMS.toLong())
                     if (!mFrameAvailable) {
                         throw RuntimeException("Surface frame wait timed out")

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressorHelper.kt

@@ -5,6 +5,7 @@ import android.content.Context
 import android.media.MediaMetadataRetriever
 import android.net.Uri
 import android.os.Handler
+import android.os.Looper
 import android.os.PowerManager
 import android.os.PowerManager.WakeLock
 import com.facebook.react.bridge.LifecycleEventListener
@@ -58,7 +59,9 @@ class VideoCompressorHelper {
             if (!wakeLock!!.isHeld()) {
                 wakeLock!!.acquire()
             }
-            handler = Handler()
+            // Bind to the main Looper: under Nitro this runs on a background executor
+            // thread (no Looper), so the no-arg Handler() constructor would throw.
+            handler = Handler(Looper.getMainLooper())
             runnable = Runnable { }
             handler!!.post(runnable!!)
             return ""
@@ -100,6 +103,29 @@ class VideoCompressorHelper {
                 ?: 0
         }
 
+        /**
+         * Derive the source video frame rate. METADATA_KEY_CAPTURE_FRAMERATE
+         * is only populated for slow-motion captures, so most regular videos
+         * return 0 and downstream code falls back to a hard-coded 30 fps —
+         * which silently halves the frame count of any 60 fps source and
+         * produces visibly choppy output.
+         *
+         * Strategy: trust CAPTURE_FRAMERATE when present, otherwise compute
+         * fps from frame count / duration (API 28+ exposes the frame count
+         * via METADATA_KEY_VIDEO_FRAME_COUNT). Returns 0 if neither path
+         * yields a usable value.
+         */
+        fun getSourceFrameRate(metaRetriever: MediaMetadataRetriever): Int {
+            val capture = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)
+            if (capture > 0) return capture
+
+            val frameCount = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_FRAME_COUNT)
+            val durationMs = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_DURATION)
+            if (frameCount <= 0 || durationMs <= 0) return 0
+            val fps = (frameCount.toLong() * 1000L / durationMs.toLong()).toInt()
+            return fps.coerceIn(0, 240)
+        }
+
         fun VideoCompressManual(fileUrl: String?, options: VideoCompressorHelper, promise: Promise, reactContext: ReactApplicationContext?) {
             try {
                 val uri = Uri.parse(fileUrl)
@@ -110,7 +136,7 @@ class VideoCompressorHelper {
                 val height = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)
                 val width = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)
                 val bitrate = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_BITRATE)
-                val frameRate = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)
+                val frameRate = getSourceFrameRate(metaRetriever)
                 if (height <= 0 || width <= 0) {
                     promise.reject(Throwable("Failed to read the input video dimensions"))
                     return

package/ios/Audio/FormatConverter/FormatConverter+Compressed.swift

@@ -5,7 +5,7 @@ import AVFoundation
 // MARK: - internal helper functions
 
 
-public extension AVURLAsset {
+extension AVURLAsset {
     /// Audio format for  the file in the URL asset
     var audioFormat: AVAudioFormat? {
         // pull the input format out of the audio file...

package/ios/Audio/FormatConverter/FormatConverter+Utilities.swift

@@ -11,7 +11,7 @@ extension FormatConverter {
     }
 }
 
-public extension FormatConverter {
+extension FormatConverter {
     /// Is this file a PCM file?
     /// - Parameters:
     ///   - url: The URL to parse

package/ios/Audio/FormatConverter/FormatConverter.swift

@@ -19,7 +19,9 @@ import AVFoundation
  }
  ```
  */
-public class FormatConverter {
+// `internal` (not `public`): keeps these types out of the Swift↔C++ interop surface
+// that Nitro enables module-wide, which otherwise fails to link the nested `Options` type.
+class FormatConverter {
     // MARK: - properties
 
     /// The source audio file
@@ -122,7 +124,7 @@ public class FormatConverter {
 
 // MARK: - Definitions
 
-public enum AudioFileFormat: String {
+enum AudioFileFormat: String {
     case aac
     case aif
     case aifc
@@ -141,7 +143,7 @@ public enum AudioFileFormat: String {
     case wav
 }
 
-public extension FormatConverter {
+extension FormatConverter {
 
     /// FormatConverterCallback is the callback format for start()
     /// - Parameter: error This will contain one parameter of type Error which is nil if the conversion was successful.

package/ios/HybridCompressor.swift

@@ -0,0 +1,247 @@
+//
+//  HybridCompressor.swift
+//  react-native-compressor
+//
+//  Nitro HybridObject implementation of the single `Compressor` native module.
+//  It is a thin binding layer: it converts Nitro's `AnyMap` options into the
+//  `NSDictionary`/`[String: Any]` the existing domain code already consumes,
+//  bridges the Nitro `Promise` to the domain layer's `RCTPromiseResolveBlock`/
+//  `RCTPromiseRejectBlock`, and registers progress callbacks (keyed by `uuid`)
+//  with `EventEmitterHandler`. All heavy logic stays in the domain classes.
+//
+
+import Foundation
+import NitroModules
+
+// Previously imported from React. We define them locally so this Swift module no
+// longer needs to `import React`: under Nitro's Swift↔C++ interop, importing
+// React pulls move-only C++ types (e.g. jsinspector's RuntimeSamplingProfile)
+// into Swift's importer and fails to compile. These blocks are created here and
+// consumed by the domain layer entirely in Swift, so plain closures suffice.
+typealias RCTPromiseResolveBlock = (Any?) -> Void
+typealias RCTPromiseRejectBlock = (String?, String?, (any Error)?) -> Void
+
+private let videoCompressor = VideoCompressor()
+private let uploader = Uploader()
+
+final class HybridCompressor: HybridCompressorSpec {
+    // MARK: - Image
+
+    func image_compress(imagePath: String, optionMap: AnyMap, onDownloadProgress: ((Double) -> Void)?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        var options = dictionary(from: optionMap)
+        // Remote-image download progress is keyed by `uuid` inside the Downloader. The JS
+        // layer no longer sends one (the callback is passed directly), so mint one here.
+        let uuid = (options["uuid"] as? String) ?? UUID().uuidString
+        options["uuid"] = uuid
+        EventEmitterHandler.registerDownloadProgress(uuid: uuid, onDownloadProgress)
+        ImageMain.image_compress(imagePath, optionMap: options as NSDictionary, resolve: resolveString(promise, uuid), reject: reject(promise, uuid))
+        return promise
+    }
+
+    func getImageMetaData(filePath: String) throws -> Promise<AnyMap> {
+        let promise = Promise<AnyMap>()
+        ImageMain.getImageMetaData(filePath, resolve: resolveAnyMap(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    // MARK: - Video
+
+    func compress(fileUrl: String, optionMap: AnyMap, onProgress: ((Double) -> Void)?, onDownloadProgress: ((Double) -> Void)?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        let options = dictionary(from: optionMap)
+        let uuid = (options["uuid"] as? String) ?? ""
+        EventEmitterHandler.registerVideoCompressProgress(uuid: uuid, onProgress)
+        EventEmitterHandler.registerDownloadProgress(uuid: uuid, onDownloadProgress)
+        videoCompressor.compress(fileUrl: fileUrl, options: options, resolve: resolveString(promise, uuid), reject: reject(promise, uuid))
+        return promise
+    }
+
+    func cancelCompression(uuid: String) throws {
+        videoCompressor.cancelCompression(uuid: uuid)
+    }
+
+    func getVideoMetaData(filePath: String) throws -> Promise<AnyMap> {
+        let promise = Promise<AnyMap>()
+        videoCompressor.getVideoMetaData(filePath, resolve: resolveAnyMap(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func activateBackgroundTask(options: AnyMap, onExpired: (() -> Void)?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        EventEmitterHandler.setBackgroundTaskExpiredCallback(onExpired)
+        videoCompressor.activateBackgroundTask(options: dictionary(from: options), resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func deactivateBackgroundTask(options: AnyMap) throws -> Promise<String> {
+        let promise = Promise<String>()
+        EventEmitterHandler.setBackgroundTaskExpiredCallback(nil)
+        videoCompressor.deactivateBackgroundTask(options: dictionary(from: options), resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    // MARK: - Audio
+
+    func compress_audio(fileUrl: String, optionMap: AnyMap) throws -> Promise<String> {
+        let promise = Promise<String>()
+        AudioMain.compress_audio(fileUrl, optionMap: dictionary(from: optionMap) as NSDictionary, resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    // MARK: - Upload / Download
+
+    func upload(fileUrl: String, options: AnyMap, onProgress: ((Double, Double) -> Void)?) throws -> Promise<AnyMap> {
+        let promise = Promise<AnyMap>()
+        let dict = dictionary(from: options)
+        let uuid = (dict["uuid"] as? String) ?? ""
+        EventEmitterHandler.registerUploadProgress(uuid: uuid, onProgress)
+        uploader.upload(filePath: fileUrl, options: dict, resolve: resolveAnyMap(promise, uuid), reject: reject(promise, uuid))
+        return promise
+    }
+
+    func cancelUpload(uuid: String, shouldCancelAll: Bool) throws {
+        uploader.cancelUpload(uuid: uuid, shouldCancelAll: shouldCancelAll)
+    }
+
+    func download(fileUrl: String, options: AnyMap, onProgress: ((Double) -> Void)?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        let dict = dictionary(from: options)
+        let uuid = (dict["uuid"] as? String) ?? ""
+        let progressDivider = (dict["progressDivider"] as? NSNumber)?.intValue ?? 0
+        EventEmitterHandler.registerDownloadProgress(uuid: uuid, onProgress)
+        Downloader.downloadFileAndSaveToCache(fileUrl, uuid: uuid, progressDivider: progressDivider) { downloadedPath in
+            EventEmitterHandler.unregister(uuid: uuid)
+            promise.resolve(withResult: downloadedPath)
+        }
+        return promise
+    }
+
+    // MARK: - Others
+
+    func generateFilePath(fileExtension: String) throws -> Promise<String> {
+        let promise = Promise<String>()
+        Utils.generateFilePath(fileExtension, resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func getRealPath(path: String, type: String) throws -> Promise<String> {
+        let promise = Promise<String>()
+        Utils.getRealPath(path, type: type, resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func getFileSize(filePath: String) throws -> Promise<String> {
+        let promise = Promise<String>()
+        Utils.getFileSize(filePath, resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func createVideoThumbnail(fileUrl: String, options: AnyMap) throws -> Promise<VideoThumbnailResult> {
+        let promise = Promise<VideoThumbnailResult>()
+        let thumbnail = CreateVideoThumbnail()
+        thumbnail.create(fileUrl, options: dictionary(from: options) as NSDictionary, resolve: { value in
+            let dict = HybridCompressor.stringKeyedDictionary(value)
+            let result = VideoThumbnailResult(
+                path: dict["path"] as? String ?? "",
+                size: HybridCompressor.doubleValue(dict["size"]),
+                mime: dict["mime"] as? String ?? "",
+                width: HybridCompressor.doubleValue(dict["width"]),
+                height: HybridCompressor.doubleValue(dict["height"])
+            )
+            promise.resolve(withResult: result)
+        }, rejecter: reject(promise, nil))
+        return promise
+    }
+
+    func clearCache(cacheDir: String?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        CreateVideoThumbnail.cleanCacheDir(cacheDir: cacheDir ?? "", resolve: resolveString(promise, nil), rejecter: reject(promise, nil))
+        return promise
+    }
+
+    // MARK: - Helpers
+
+    /// Convert a Nitro `AnyMap` to a `[String: Any]`, round-tripping through
+    /// `NSDictionary` so numbers are boxed as `NSNumber` (the domain parsers rely
+    /// on `as? Int` / `as? Bool`, which fail on a bare Swift `Double`).
+    private func dictionary(from map: AnyMap) -> [String: Any] {
+        let normalized = (HybridCompressor.normalize(map.toDictionary()) as? [String: Any]) ?? [:]
+        return ((normalized as NSDictionary) as? [String: Any]) ?? normalized
+    }
+
+    private func resolveString(_ promise: Promise<String>, _ uuid: String?) -> RCTPromiseResolveBlock {
+        return { value in
+            if let uuid = uuid { EventEmitterHandler.unregister(uuid: uuid) }
+            promise.resolve(withResult: value as? String ?? "")
+        }
+    }
+
+    private func resolveAnyMap(_ promise: Promise<AnyMap>, _ uuid: String?) -> RCTPromiseResolveBlock {
+        return { value in
+            if let uuid = uuid { EventEmitterHandler.unregister(uuid: uuid) }
+            promise.resolve(withResult: AnyMap.fromDictionaryIgnoreIncompatible(HybridCompressor.stringKeyedOptionalDictionary(value)))
+        }
+    }
+
+    private func reject<T>(_ promise: Promise<T>, _ uuid: String?) -> RCTPromiseRejectBlock {
+        return { code, message, error in
+            if let uuid = uuid { EventEmitterHandler.unregister(uuid: uuid) }
+            let nsError = error ?? RuntimeError.error(withMessage: message ?? code ?? "react-native-compressor error")
+            promise.reject(withError: nsError)
+        }
+    }
+
+    /// Recursively strip optionals so a `[String: Any?]` (what `AnyMap.toDictionary()`
+    /// returns, including nested objects/arrays) becomes a plain `[String: Any]`.
+    private static func normalize(_ value: Any?) -> Any? {
+        switch value {
+        case let dict as [String: Any?]:
+            var out = [String: Any]()
+            for (key, nested) in dict {
+                if let nestedValue = normalize(nested) { out[key] = nestedValue }
+            }
+            return out
+        case let array as [Any?]:
+            return array.compactMap { normalize($0) }
+        default:
+            return value
+        }
+    }
+
+    private static func stringKeyedDictionary(_ value: Any?) -> [String: Any] {
+        if let dict = value as? [String: Any] { return dict }
+        if let ns = value as? NSDictionary {
+            var out = [String: Any]()
+            for (key, val) in ns where key is String {
+                out[key as! String] = val
+            }
+            return out
+        }
+        return [:]
+    }
+
+    private static func stringKeyedOptionalDictionary(_ value: Any?) -> [String: Any?] {
+        if let ns = value as? NSDictionary {
+            var out = [String: Any?]()
+            for (key, val) in ns where key is String {
+                out[key as! String] = val
+            }
+            return out
+        }
+        if let dict = value as? [String: Any] {
+            var out = [String: Any?]()
+            for (key, val) in dict { out[key] = val }
+            return out
+        }
+        return [:]
+    }
+
+    private static func doubleValue(_ value: Any?) -> Double {
+        if let number = value as? NSNumber { return number.doubleValue }
+        if let double = value as? Double { return double }
+        if let float = value as? Float { return Double(float) }
+        if let int = value as? Int { return Double(int) }
+        return 0
+    }
+}

package/ios/Image/ImageCompressor.swift

@@ -1,11 +1,17 @@
 import Accelerate
 import CoreGraphics
 import Photos
-import React
 import Foundation
 import MobileCoreServices
 
 
+// Local stand-in for the single `RCTResizeMode` case this file relies on, so the
+// module no longer needs to `import React` (see HybridCompressor for the reason).
+private enum CompressorResizeMode {
+    case contain
+}
+
+
 class ImageCompressor {
     static func findTargetSize(_ image: UIImage, maxWidth: Int, maxHeight: Int) -> CGSize {
         let width = image.size.width
@@ -392,7 +398,7 @@ class ImageCompressor {
             let imageURL = URL(string: imagePath.replacingOccurrences(of: " ", with: "%20"))
             var size = CGSize.zero
             var scale: CGFloat = 1
-            var resizeMode = RCTResizeMode.contain
+            var resizeMode = CompressorResizeMode.contain
             let assetID = imagePath.replacingOccurrences(of: "ph://", with: "")
             let results = PHAsset.fetchAssets(withLocalIdentifiers: [assetID], options: nil)
             

package/ios/Utils/EventEmitterHandler.swift

@@ -6,49 +6,71 @@
 //
 
 import Foundation
+import UIKit
 
+/// Routes native progress emissions to the per-call JS callbacks that
+/// `HybridCompressor` registers. This replaces the old `RCTEventEmitter` bridge:
+/// Nitro delivers progress through callback parameters, so the domain layer's
+/// `emit*` calls (unchanged) are dispatched to the callback registered under the
+/// same `uuid` that the JS layer threads through the options map.
 class EventEmitterHandler {
-    static var sharedCompressorObject: Any!
-    static var hasListener: Bool=false
-    
-    static func initCompressorInstance(_ object: Any) {
-        sharedCompressorObject = object
+    private static let lock = NSLock()
+    private static var videoCompressProgressCallbacks = [String: (Double) -> Void]()
+    private static var downloadProgressCallbacks = [String: (Double) -> Void]()
+    private static var uploadProgressCallbacks = [String: (Double, Double) -> Void]()
+    private static var backgroundTaskExpiredCallback: (() -> Void)?
+
+    // MARK: - Registration (called by HybridCompressor)
+
+    static func registerVideoCompressProgress(uuid: String, _ callback: ((Double) -> Void)?) {
+        guard let callback = callback else { return }
+        lock.lock(); defer { lock.unlock() }
+        videoCompressProgressCallbacks[uuid] = callback
+    }
+
+    static func registerDownloadProgress(uuid: String, _ callback: ((Double) -> Void)?) {
+        guard let callback = callback else { return }
+        lock.lock(); defer { lock.unlock() }
+        downloadProgressCallbacks[uuid] = callback
     }
-    
-    
-    static func stopObserving() -> Void {
-      hasListener = false
+
+    static func registerUploadProgress(uuid: String, _ callback: ((Double, Double) -> Void)?) {
+        guard let callback = callback else { return }
+        lock.lock(); defer { lock.unlock() }
+        uploadProgressCallbacks[uuid] = callback
+    }
+
+    static func unregister(uuid: String) {
+        lock.lock(); defer { lock.unlock() }
+        videoCompressProgressCallbacks[uuid] = nil
+        downloadProgressCallbacks[uuid] = nil
+        uploadProgressCallbacks[uuid] = nil
     }
 
-    static func startObserving() -> Void {
-      hasListener = true
+    static func setBackgroundTaskExpiredCallback(_ callback: (() -> Void)?) {
+        lock.lock(); defer { lock.unlock() }
+        backgroundTaskExpiredCallback = callback
     }
-    
+
+    // MARK: - Emission (called by the domain layer — method names preserved)
+
     static func emitDownloadProgress(_ progress: NSNumber, uuid: String) {
-        var params = [String: Any]()
-        var data = [String: Any]()
-        params["uuid"] = uuid
-        data["progress"] = progress
-        params["data"] = data
-        
-        (sharedCompressorObject as AnyObject).sendEvent(withName: "downloadProgress", body: params)
-    }
-    
+        lock.lock(); let callback = downloadProgressCallbacks[uuid]; lock.unlock()
+        callback?(progress.doubleValue)
+    }
+
     static func emitVideoCompressProgress(_ progress: Float, uuid: String) {
-        if(self.hasListener){
-            (sharedCompressorObject as AnyObject).sendEvent(withName: "videoCompressProgress", body: ["uuid": uuid, "data": ["progress": progress]])
-        }
+        lock.lock(); let callback = videoCompressProgressCallbacks[uuid]; lock.unlock()
+        callback?(Double(progress))
     }
-    
+
     static func emituploadProgress(_ uuid: String, totalBytesSent: Int64, totalBytesExpectedToSend: Int64) {
-        if(self.hasListener){
-            (sharedCompressorObject as AnyObject).sendEvent(withName: "uploadProgress", body: ["uuid": uuid, "data": ["written": totalBytesSent, "total": totalBytesExpectedToSend]])
-        }
-    }
-    
-    static func emitBackgroundTaskExpired(_ backgroundTaskId:UIBackgroundTaskIdentifier) {
-        if(self.hasListener){
-            (sharedCompressorObject as AnyObject).sendEvent(withName: "backgroundTaskExpired", body: ["backgroundTaskId": backgroundTaskId])
-        }
+        lock.lock(); let callback = uploadProgressCallbacks[uuid]; lock.unlock()
+        callback?(Double(totalBytesSent), Double(totalBytesExpectedToSend))
+    }
+
+    static func emitBackgroundTaskExpired(_ backgroundTaskId: UIBackgroundTaskIdentifier) {
+        lock.lock(); let callback = backgroundTaskExpiredCallback; lock.unlock()
+        callback?()
     }
 }

package/ios/Video/NextLevelSessionExporter.swift

@@ -13,7 +13,9 @@ public enum NextLevelSessionExporterError: Error, CustomStringConvertible {
     case readingFailure
     case writingFailure
     case cancelled
-    
+    case unsupportedVideoOutputConfiguration
+    case missingVideoTrackInOutput
+
     public var description: String {
         get {
             switch self {
@@ -25,6 +27,10 @@ public enum NextLevelSessionExporterError: Error, CustomStringConvertible {
                 return "Writing failure"
             case .cancelled:
                 return "Cancelled"
+            case .unsupportedVideoOutputConfiguration:
+                return "The writer rejected the video output configuration"
+            case .missingVideoTrackInOutput:
+                return "Export finished without a video track in the output"
             }
         }
     }
@@ -249,7 +255,16 @@ extension NextLevelSessionExporter {
             }
         }
         
-        self.setupVideoOutput(withAsset: asset)
+        // Fail loudly when the writer rejects the video output configuration.
+        // Continuing here used to export only the audio track and still resolve
+        // as a success (issue #400).
+        guard self.setupVideoOutput(withAsset: asset) else {
+            DispatchQueue.main.async {
+                self._completionHandler?(.failure(NextLevelSessionExporterError.unsupportedVideoOutputConfiguration))
+                self._completionHandler = nil
+            }
+            return
+        }
         if !self.stripAudio {
             self.setupAudioOutput(withAsset: asset)
             self.setupAudioInput()
@@ -316,11 +331,14 @@ extension NextLevelSessionExporter {
 
 extension NextLevelSessionExporter {
     
-    private func setupVideoOutput(withAsset asset: AVAsset) {
+    /// Returns `false` when the asset has video tracks but a video writer input
+    /// could not be created — exporting would silently produce an audio-only
+    /// file (see numandev1/react-native-compressor#400).
+    private func setupVideoOutput(withAsset asset: AVAsset) -> Bool {
         let videoTracks = asset.tracks(withMediaType: AVMediaType.video)
-        
+
         guard videoTracks.count > 0 else {
-            return
+            return true
         }
         
         self._videoOutput = AVAssetReaderVideoCompositionOutput(videoTracks: videoTracks, videoSettings: self.videoInputConfiguration)
@@ -344,8 +362,8 @@ extension NextLevelSessionExporter {
             self._videoInput = AVAssetWriterInput(mediaType: AVMediaType.video, outputSettings: self.videoOutputConfiguration)
             self._videoInput?.expectsMediaDataInRealTime = self.expectsMediaDataInRealTime
         } else {
-            print("Unsupported output configuration")
-            return
+            print("NextLevelSessionExporter, unsupported video output configuration, failing export instead of writing an audio-only file")
+            return false
         }
         
         if let writer = self._writer,
@@ -367,8 +385,9 @@ extension NextLevelSessionExporter {
             
             self._pixelBufferAdaptor = AVAssetWriterInputPixelBufferAdaptor(assetWriterInput: videoInput, sourcePixelBufferAttributes: pixelBufferAttrib)
         }
+        return true
     }
-    
+
     private func setupAudioOutput(withAsset asset: AVAsset) {
         let audioTracks = asset.tracks(withMediaType: AVMediaType.audio)
         var audioTracksToUse: [AVAssetTrack] = []
@@ -632,6 +651,22 @@ extension NextLevelSessionExporter {
             break
         }
 
+        // Guard against silently returning an audio-only file: when the source
+        // has a video track and a video output was configured, the exported file
+        // must contain a video track as well. A configuration the encoder rejects
+        // at write time can still end with `.completed` while the video track is
+        // dropped (issue #400) — surface that as an error instead of a success.
+        if self.videoOutputConfiguration != nil,
+           let asset = self.asset,
+           let outputURL = self.outputURL,
+           asset.tracks(withMediaType: AVMediaType.video).count > 0,
+           AVAsset(url: outputURL).tracks(withMediaType: AVMediaType.video).count == 0 {
+            try? FileManager.default.removeItem(at: outputURL)
+            self._completionHandler?(.failure(NextLevelSessionExporterError.missingVideoTrackInOutput))
+            self._completionHandler = nil
+            return
+        }
+
         self._completionHandler?(.success(self.status))
         self._completionHandler = nil
     }