react-native-attachment-kit 1.0.18 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.1.1 — 2026-11-03
+
+- **Viewer: `sourceClipInsets` / `sourceClipRect` options — the zoom open / close stays behind translucent bars (iOS + Android `useOverlayViewer`)**. The moving photo and the `hideSourceImage` mask are drawn in the window above the app, so a thumbnail half under the app's translucent top bar flew back *over* the bar and the mask covered the bar too. With a clip area (screen-edge insets, a rect in `sourceRect` coordinates, or both = intersection) they are drawn only inside it: on open the photo starts cut at the bar and the clip widens to the full screen during the second half (the viewer itself is never cut); on close it narrows back in the first 20 % (the viewer background turns transparent at once on close, so the photo never covers the bar), and the part under the bar disappears behind it. Checked on the iOS simulator (HeyTalk feed): a cell half under the translucent top bar opens from behind the bar and closes back behind it; a cell clear of the bar animates as before. `updateSourceRect` takes the same keys (changed only when passed, `null` = no clip) for paging to another thumbnail. Without the options nothing changes.
+  - iOS: `ZoomTransitionAnimator.sourceClipRect` / `sourceClipInsets` (public) — the dummy image sits in a full-screen view whose `mask` view animates between the clip and the bounds; the source mask sits in a holder of the clip's size (`clipsToBounds`). Other users of the animator (gallery, media gallery) pass nothing.
+  - Android: `ImageViewerOverlayView` sets `clipBounds` on the dummy image (lerped with the open / close progress) and on the mask (its own coordinates, refreshed whenever the mask moves). Insets are measured from the window's decor view. The Activity / Dialog viewers ignore the options.
+## 1.1.0 — 2026-10-27
+
+- **New public API for native screens: `AttachmentProcessor` (iOS framework + Android aar)** — the "after picking" processing that used to live only inside the RN bridge (photo resize and save as webp / jpg / png, photo thumbnail, video export with `VideoExporter` and its poster, the processing-start slots with predicted sizes and posters, progress throttling, per-video cancel, temp files and the result model). An app's own native screen can now open the kit gallery and process the result with exactly the same code as `openGallery`, so both produce the same files (size, thumbnail, poster).
+  - iOS: `AttachmentProcessor.process(_:videoStates:options:job:onStart:onVideoProgress:onItem:)`, `startItem`, `processPhoto`, `processVideo`, and the helpers (`resizeImage`, `saveImage`, `encodeWebP`, `makePhotoThumbnail`, `photoThumbnailLayout`, `videoFrame`, `requestPoster`, `prepareCacheDirectory` …). Models `AttachmentProcessingOptions`, `AttachmentStartItem`, `AttachmentResult` (`.dictionary` = the RN result fields), `AttachmentProcessingJob` (`cancel(index:)` / `abort()`), `AttachmentProgressThrottle`; `PhotoThumbnailOptions` is now public.
+  - Android: `com.rnattachmentkit.AttachmentProcessor` (`process` / `processPhoto` / `processVideo` are `suspend`), `Options`, `Result` (`toMap()` = the RN result fields), `Listener`; `ProcessingJob.abort()` / `isAborted`.
+  - The RN bridge (`openGallery` on both platforms, iOS `openEditor` video / photo paths) now calls these — no change in the JS API, events or result fields. The progress HUD's cancel is `job.abort()` (whole send cancelled, Promise rejected as before).
+- **Android: the aar is exposed to the app (`api`)**, together with `material` and `media3-transformer` (supertypes / signatures of public classes). An app's native code can use the kit classes without its own `compileOnly` copy of the aar. Class names are kept by the aar's `-keep class com.rnattachmentkit.** { *; }`; apps that minify keep the same rule in their `proguard-rules.pro` (HeyTalk / ZemTalk already do).
+- **License: `LicenseManager.isInitialized` and `whenInitialized(timeout:)` (iOS + Android)** — lets a native screen wait for the RN side's `AttachmentKit.init` before it opens the gallery or processes anything (the gallery's video permission and the photo watermark read the license).
+- Checked in HeyTalk (new devices `HeyTalk_KIT` simulator / emulator, one batch of a 4032×3024 jpg + a 1080p 6 s mp4): on iOS and on Android the RN `openGallery` path and the app's native chat room produced byte-identical photo webp (1024×768), processing-start poster and export poster, and mp4s with the same codec, size, duration, frame count, bitrate and byte count (only the mp4 creation time differs). An Android photo bug introduced while moving the code (bounds-only decode treated as failure, so every photo was dropped) was found by that check and fixed before this build. ZemTalk: iOS device build (no signing) and Android Kotlin/Java compile pass with no change to ZemTalk.
+
 ## 1.0.18 — 2026-10-23
 
 - **Image viewer (iOS) and full-screen camera (iOS + Android): pull-down follows the finger back up freely**, like the editor. Before, dragging down and then back above the starting point made the photo / camera stop at a fixed height.

package/README.md

@@ -341,6 +341,8 @@ ref.current?.measure((x, y, width, height, pageX, pageY) => {
 | `sourceBorderCorners` | `('topLeft' \| 'topRight' \| 'bottomLeft' \| 'bottomRight')[]` | Which corners are rounded (chat-bubble groups). `[]` = none. |
 | `sourceBackgroundColor` | `string` | Background behind the thumbnail during the animation. |
 | `hideSourceImage` | `boolean` | A native mask hides the source thumbnail while the viewer is open. |
+| `sourceClipInsets` | `{ top?, bottom?, left?, right? }` | Screen-edge insets of the area where the **moving photo and the `hideSourceImage` mask** are drawn during the zoom open / close (e.g. `{ top: headerHeight, bottom: tabBarHeight }` for translucent bars). A thumbnail half under a translucent bar then slides **behind** the bar instead of over it. The clip widens to the full screen in the second half of the open (when the viewer background covers the bar) and narrows in the first 20 % of the close, so the viewer itself is never cut. iOS + Android `useOverlayViewer`. |
+| `sourceClipRect` | `SourceRect` | Same, as a rect in `sourceRect` coordinates (e.g. a list area inside a sheet). With both, the intersection is used. Omit both = no clipping (as before). |
 
 **Actions**
 
@@ -368,8 +370,8 @@ ref.current?.measure((x, y, width, height, pageX, pageY) => {
 | `useDialogViewer: true` | DialogFragment — no `AppState` blip, but background RN layout changes may not render until it closes. |
 | `useOverlayViewer: true` | ⭐ View on top of the host Activity's window — no `AppState` blip, background changes render in real time. Wins over `useDialogViewer`. |
 
-#### `updateSourceRect(rect: SourceRect & { sourceBorderRadius?, sourceBorderCorners? }): Promise<void>`
-Updates where the viewer closes to (e.g. after paging to another thumbnail or scrolling).
+#### `updateSourceRect(rect: ViewerSourceUpdate): Promise<void>`
+Updates where the viewer closes to (e.g. after paging to another thumbnail or scrolling). `ViewerSourceUpdate = SourceRect & { sourceBorderRadius?, sourceBorderCorners?, sourceClipRect?, sourceClipInsets? }` — the clip keys change only when passed (`null` = stop clipping).
 
 #### `injectImageCache(url: string, localPath: string): Promise<boolean>`
 Seeds the viewer's image cache with a local file for a remote URL, so it opens instantly without network.

package/android/build.gradle

@@ -97,7 +97,10 @@ if (project != rootProject) {
     }
 
     dependencies {
-        implementation files('src/main/libs/rnattachmentkit-release.aar')
+        // 1.1.0: aar 를 `api` 로 — 앱의 네이티브 코드도 키트 공개 클래스(AttachmentProcessor·ImagePickerBottomSheet·
+        //   ImageViewerOverlayView·VideoExporter …)를 바로 쓸 수 있게 (전엔 앱이 같은 aar 를 compileOnly 로 따로 잡아야 했음).
+        //   클래스 이름은 aar 의 proguard-rules.pro(-keep class com.rnattachmentkit.**)가 그대로 둠
+        api files('src/main/libs/rnattachmentkit-release.aar')
         compileOnly "com.facebook.react:react-android:+"
         
         implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.0"
@@ -107,7 +110,8 @@ if (project != rootProject) {
         implementation "androidx.fragment:fragment-ktx:1.6.2"
         implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
         implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
-        implementation "com.google.android.material:material:1.11.0"
+        // 공개 클래스의 부모 타입(BottomSheetDialogFragment 등)이라 앱 컴파일 경로에도 보여야 함
+        api "com.google.android.material:material:1.11.0"
         implementation "androidx.recyclerview:recyclerview:1.3.2"
         implementation "androidx.cardview:cardview:1.0.0"
         implementation "androidx.coordinatorlayout:coordinatorlayout:1.2.0"
@@ -132,7 +136,8 @@ if (project != rootProject) {
         // 이미지 뷰어 동영상: HLS(.m3u8) 스트리밍 재생 (iOS AVPlayer 와 맞춤)
         implementation "androidx.media3:media3-exoplayer-hls:${media3_version}"
         implementation "androidx.media3:media3-ui:${media3_version}"
-        implementation "androidx.media3:media3-transformer:${media3_version}"
+        // VideoExporter 공개 API 가 쓰는 타입 — 앱 컴파일 경로에도 보여야 함
+        api "androidx.media3:media3-transformer:${media3_version}"
         implementation "androidx.media3:media3-effect:${media3_version}"
 
         // CameraX dependencies — 1.4.0+ 부터 libimage_processing_util_jni.so 가 16KB 정렬 (AAR 쪽과 같은 버전)

package/android/src/newarch/java/com/rnattachmentkit/RNAttachmentKitModule.kt

@@ -47,8 +47,6 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
     private var lastMaxSelection: Int = 10
     private var lastThemeColorInt: Int? = null
     private var lastLanguageCode: String = "en"
-    @Volatile private var currentVideoExporter: com.rnattachmentkit.VideoExporter? = null
-    @Volatile private var videoCancelled = false
     /** 진행 중인 전송 처리 (processingId → 작업). 보내는 중에 갤러리를 다시 열어 또 보낼 수 있어 여러 개일 수 있음 */
     private val activeProcessingJobs = java.util.concurrent.ConcurrentHashMap<String, com.rnattachmentkit.ProcessingJob>()
     /** 가장 최근에 시작한 처리 (cancelVideoProcessing 에 processingId 가 없을 때) */
@@ -214,12 +212,33 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
             }
         }
 
+        // 잘라내기 영역 — 넘긴 키만 바뀜 (useOverlayViewer 뷰어만 반영)
+        clipArrayOf(options, "sourceClipRect")?.let { intent.putExtra("sourceClipRect", it) }
+        clipArrayOf(options, "sourceClipInsets")?.let { intent.putExtra("sourceClipInsets", it) }
         androidx.localbroadcastmanager.content.LocalBroadcastManager.getInstance(reactApplicationContext)
             .sendBroadcast(intent)
             
         promise.resolve(null)
     }
 
+    /**
+     * sourceClipRect {x,y,width,height} / sourceClipInsets {top,bottom,left,right} (dp) → 화면 px [l,t,r,b]
+     * (여백이면 각 변의 여백). 키가 없으면 null(안 바꿈), 값이 null 이면 빈 배열(자르지 않음).
+     */
+    private fun clipArrayOf(options: ReadableMap, key: String): FloatArray? {
+        if (!options.hasKey(key)) return null
+        if (options.isNull(key)) return FloatArray(0)
+        val m = options.getMap(key) ?: return FloatArray(0)
+        fun px(k: String) = if (m.hasKey(k) && !m.isNull(k)) com.facebook.react.uimanager.PixelUtil.toPixelFromDIP(m.getDouble(k).toFloat()) else 0f
+        return if (key == "sourceClipRect") {
+            val x = px("x")
+            val y = px("y")
+            floatArrayOf(x, y, x + px("width"), y + px("height"))
+        } else {
+            floatArrayOf(px("left"), px("top"), px("right"), px("bottom"))
+        }
+    }
+
     override fun getName(): String = NAME
 
     override fun init(licenseKey: String, promise: Promise) {
@@ -666,6 +685,9 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                     if (options.hasKey("sourceBackgroundColor")) {
                         putString("sourceBackgroundColor", options.getString("sourceBackgroundColor"))
                     }
+                    // 잘라내기 영역 (열림·닫힘 중 사진과 가림 판이 그려지는 곳) — 이 오버레이 뷰어만
+                    clipArrayOf(options, "sourceClipRect")?.let { putFloatArray("sourceClipRect", it) }
+                    clipArrayOf(options, "sourceClipInsets")?.let { putFloatArray("sourceClipInsets", it) }
                     // placeholderImages: 타입/뷰어 코드에는 있었지만 브릿지에서 한 번도 전달되지 않았던
                     // 필드. 네이티브 뷰어가 onlyRetrieveFromCache(true)로 첫 프레임을 즉시 그리려 할 때
                     // 쓰는 저해상도 대체 이미지 목록입니다(원본 다운로드 전 임시 표시용).
@@ -985,374 +1007,93 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    /** 고른 뒤 처리 — com.rnattachmentkit.AttachmentProcessor (앱 네이티브 화면과 같은 코드). 여기선 RN 이벤트·HUD 만 */
     private suspend fun processImages(uris: List<Uri>, snap: SendSnapshot): List<com.facebook.react.bridge.WritableMap> = withContext(Dispatchers.IO) {
-        // 보낸 순간의 설정 (모듈 필드와 같은 이름으로 가림 — 아래 코드는 그대로)
-        val maxWidth = snap.maxWidth
-        val maxHeight = snap.maxHeight
-        val outputFormat = snap.outputFormat
-        val videoOptions = snap.videoOptions
-        val lastVideoEditStates = snap.states
-        val showVideoHUD = snap.showHUD
-        val lastThemeColorInt = snap.themeColor
-        val lastLanguageCode = snap.language
-        val thumbnailOptions = snap.thumbnail
         val processingId = java.util.UUID.randomUUID().toString()
-        val results = mutableListOf<com.facebook.react.bridge.WritableMap>()
-        val contentResolver = reactApplicationContext.contentResolver
         val totalCount = uris.size
-        var currentIndex = 0
-
-        // 동영상이 섞여 있으면 진행 HUD 를 띄우고, 동영상은 VideoExporter 로 (사진 처리와 같은 루프)
-        val isVideoUri: (Uri) -> Boolean = { u ->
-            u.toString().contains("/video/") || (try { contentResolver.getType(u)?.startsWith("video/") == true } catch (_: Exception) { false })
-        }
-        val hasVideo = uris.any(isVideoUri)
-        videoCancelled = false
+        val options = com.rnattachmentkit.AttachmentProcessor.Options(
+            maxWidth = snap.maxWidth, maxHeight = snap.maxHeight, outputFormat = snap.outputFormat,
+            thumbnail = snap.thumbnail, videoOptions = snap.videoOptions,
+        )
+        val hasVideo = uris.any { com.rnattachmentkit.AttachmentProcessor.isVideoUri(reactApplicationContext, it) }
+        // 앱의 cancelVideoProcessing(index) → job.cancel, HUD 의 취소 → job.abort (전체 취소)
         val job = com.rnattachmentkit.ProcessingJob()
         activeProcessingJobs[processingId] = job
         lastProcessingId = processingId
-        // ✅ 처리 시작: 모든 자리(사진·동영상)를 먼저 알림 → 앱이 말풍선을 바로 만들고 진행률을 그림
-        try {
-            val items = Arguments.createArray()
-            uris.forEachIndexed { i, u ->
-                val it0 = if (isVideoUri(u)) {
-                    val st = lastVideoEditStates[u.toString()] ?: com.rnattachmentkit.VideoEditState(qualityHeight = videoOptions.defaultQuality)
-                    com.rnattachmentkit.MediaProcessing.videoItem(reactApplicationContext, i, u, st, videoOptions)
-                } else {
-                    com.rnattachmentkit.MediaProcessing.imageItem(reactApplicationContext, i, u, maxWidth, maxHeight)
-                }
-                items.pushMap(Arguments.createMap().apply {
-                    putInt("index", it0.index)
-                    putString("mediaType", if (it0.isVideo) "video" else "image")
-                    putString("originalUri", it0.originalUri)
-                    putInt("width", it0.width)
-                    putInt("height", it0.height)
-                    it0.durationSec?.let { d -> putDouble("duration", d) }
-                    it0.thumbnailUri?.let { t ->
-                        putString("thumbnailUri", t)
-                        putInt("thumbnailWidth", it0.thumbnailWidth)
-                        putInt("thumbnailHeight", it0.thumbnailHeight)
-                    }
-                })
-            }
-            emitGalleryEvent("onProcessingStart", Arguments.createMap().apply {
-                putString("processingId", processingId)
-                putInt("total", totalCount)
-                putArray("items", items)
-            })
-        } catch (e: Exception) {
-            android.util.Log.w("RNAttachmentKit", "onProcessingStart failed: ${e.message}")
-        }
         var hud: com.rnattachmentkit.VideoExportHUD? = null
-        if (hasVideo && showVideoHUD) {
+        if (hasVideo && snap.showHUD) {
             withContext(Dispatchers.Main) {
                 val act = getCurrentActivity() ?: return@withContext
-                hud = com.rnattachmentkit.VideoExportHUD(act, lastThemeColorInt, lastLanguageCode).also { h ->
-                    h.onCancel = {
-                        videoCancelled = true
-                        currentVideoExporter?.cancel()
-                    }
+                hud = com.rnattachmentkit.VideoExportHUD(act, snap.themeColor, snap.language).also { h ->
+                    h.onCancel = { job.abort() }
                     h.show()
                 }
             }
         }
-        val videoFiles = mutableListOf<File>()
-
+        val main = android.os.Handler(android.os.Looper.getMainLooper())
+        val emitter = { reactApplicationContext.getJSModule(com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter::class.java) }
         try {
-        for (uri in uris) {
-            if (videoCancelled) throw com.rnattachmentkit.VideoExporter.CancelledException()
-            if (isVideoUri(uri)) {
-                val idx = currentIndex
-                val exporter = com.rnattachmentkit.VideoExporter(reactApplicationContext)
-                currentVideoExporter = exporter
-                val cancelledMap = {
-                    WritableNativeMap().apply {
-                        putString("originalUri", uri.toString())
-                        putString("mediaType", "video")
-                        putString("error", "CANCELLED")
-                        putBoolean("cancelled", true)
-                    }
-                }
-                val resultMap = try {
-                    // 앱이 이미 취소한 동영상은 건너뜀
-                    if (job.isCancelled(idx)) throw com.rnattachmentkit.VideoExporter.CancelledException()
-                    job.begin(idx, exporter)
-                    val state = lastVideoEditStates[uri.toString()] ?: com.rnattachmentkit.VideoEditState(qualityHeight = videoOptions.defaultQuality)
-                    val throttle = com.rnattachmentkit.ProgressThrottle()
-                    val onProgress: (Float) -> Unit = { p ->
-                        hud?.let { h -> android.os.Handler(android.os.Looper.getMainLooper()).post { h.update(p, idx, totalCount) } }
-                        if (throttle.shouldSend(p)) emitGalleryEvent("onVideoProgress", Arguments.createMap().apply {
-                            putInt("index", idx); putInt("total", totalCount); putDouble("progress", p.toDouble())
-                            putString("processingId", processingId)
-                        })
-                    }
-                    // 편집 화면에서 미리 만들어 둔 파일이 있으면(또는 만드는 중이면 끝나고) 그대로 씀
-                    // 기다리는 동안 앱(X)이나 HUD 가 취소하면 바로 멈춤 (전엔 미리 만들기가 끝날 때까지 못 빠져나왔음)
-                    val stop = { videoCancelled || job.isCancelled(idx) }
-                    val res = com.rnattachmentkit.VideoPrepareManager.takeReady(uri, state, onProgress, stop)
-                        ?: run {
-                            if (stop()) throw com.rnattachmentkit.VideoExporter.CancelledException()
-                            exporter.export(uri, state, videoOptions, reactApplicationContext.cacheDir, "turbo_video_${System.currentTimeMillis()}_$idx", onProgress)
-                        }
-                    withContext(Dispatchers.Main) { hud?.update(1f, idx, totalCount) }
-                    // 미리 만든 파일을 기다리는 동안 취소됐으면 결과를 쓰지 않음
-                    if (job.isCancelled(idx)) throw com.rnattachmentkit.VideoExporter.CancelledException()
-                    videoFiles += res.file
-                    res.thumbnailFile?.let { videoFiles += it }
-                    WritableNativeMap().apply {
-                        putString("uri", Uri.fromFile(res.file).toString())
-                        putString("originalUri", uri.toString())
-                        putString("mediaType", "video")
-                        putString("type", "video/mp4")
-                        putInt("width", res.width)
-                        putInt("height", res.height)
-                        putDouble("duration", res.durationMs / 1000.0)
-                        putDouble("fileSize", res.fileSize.toDouble())
-                        putString("fileName", res.file.name)
-                        putString("fileExtension", "mp4")
-                        putString("videoCodec", res.codec)
-                        putInt("videoBitrate", res.bitrate)
-                        putBoolean("edited", res.edited)
-                        if (res.thumbnailFile != null) {
-                            putString("thumbnailUri", Uri.fromFile(res.thumbnailFile).toString())
-                            putInt("thumbnailWidth", res.thumbnailWidth)
-                            putInt("thumbnailHeight", res.thumbnailHeight)
-                        }
-                    }
-                } catch (e: com.rnattachmentkit.VideoExporter.CancelledException) {
-                    // 앱이 이 동영상만 취소 → 나머지는 계속. HUD 취소면 전체 취소
-                    if (job.isCancelled(idx) && !videoCancelled) cancelledMap() else throw e
-                } catch (e: Exception) {
-                    // 취소하면서 변환기가 다른 예외로 끝날 수도 있음 → 취소로 처리
-                    if (job.isCancelled(idx) && !videoCancelled) cancelledMap() else {
-                        android.util.Log.w("RNAttachmentKit", "video export failed: ${e.message}", e)
-                        WritableNativeMap().apply {
-                            putString("originalUri", uri.toString())
-                            putString("mediaType", "video")
-                            putString("error", e.message ?: "export failed")
+            com.rnattachmentkit.AttachmentProcessor.process(reactApplicationContext, uris, snap.states, options, job,
+                object : com.rnattachmentkit.AttachmentProcessor.Listener {
+                    // ✅ 처리 시작: 모든 자리(사진·동영상)를 먼저 알림 → 앱이 말풍선을 바로 만들고 진행률을 그림
+                    override fun onStart(items: List<com.rnattachmentkit.MediaProcessing.StartItem>) {
+                        val arr = Arguments.createArray()
+                        items.forEach { it0 ->
+                            arr.pushMap(Arguments.createMap().apply {
+                                putInt("index", it0.index)
+                                putString("mediaType", if (it0.isVideo) "video" else "image")
+                                putString("originalUri", it0.originalUri)
+                                putInt("width", it0.width)
+                                putInt("height", it0.height)
+                                it0.durationSec?.let { d -> putDouble("duration", d) }
+                                it0.thumbnailUri?.let { t ->
+                                    putString("thumbnailUri", t)
+                                    putInt("thumbnailWidth", it0.thumbnailWidth)
+                                    putInt("thumbnailHeight", it0.thumbnailHeight)
+                                }
+                            })
                         }
-                    }
-                } finally {
-                    currentVideoExporter = null
-                    job.end()
-                }
-                results.add(resultMap)
-                try {
-                    val copy = WritableNativeMap().apply { merge(resultMap) }
-                    reactApplicationContext.getJSModule(com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                        .emit("onImageProcessed", WritableNativeMap().apply {
-                            putInt("total", totalCount); putInt("index", idx); putMap("image", copy)
+                        emitGalleryEvent("onProcessingStart", Arguments.createMap().apply {
                             putString("processingId", processingId)
+                            putInt("total", totalCount)
+                            putArray("items", arr)
                         })
-                } catch (_: Exception) {}
-                currentIndex++
-                continue
-            }
-            try {
-                // 1. Get EXIF Orientation
-                var orientation = android.media.ExifInterface.ORIENTATION_NORMAL
-                try {
-                    contentResolver.openInputStream(uri)?.use { exifInputStream ->
-                        val exif = android.media.ExifInterface(exifInputStream)
-                        orientation = exif.getAttributeInt(android.media.ExifInterface.TAG_ORIENTATION, android.media.ExifInterface.ORIENTATION_NORMAL)
                     }
-                } catch (e: Exception) {}
 
-                contentResolver.openInputStream(uri)?.use { inputStream ->
-                    // Get original image dimensions
-                    val originalOptions = BitmapFactory.Options().apply {
-                        inJustDecodeBounds = true
-                    }
-                    BitmapFactory.decodeStream(inputStream, null, originalOptions)
-                    
-                    var originalWidth = originalOptions.outWidth
-                    var originalHeight = originalOptions.outHeight
-                    
-                    // Swap width and height if rotated by 90 or 270 degrees
-                    if (orientation == android.media.ExifInterface.ORIENTATION_ROTATE_90 || orientation == android.media.ExifInterface.ORIENTATION_ROTATE_270) {
-                        val temp = originalWidth
-                        originalWidth = originalHeight
-                        originalHeight = temp
+                    override fun onVideoProgress(index: Int, progress: Float) {
+                        hud?.let { h -> main.post { h.update(progress, index, totalCount) } }
+                        emitGalleryEvent("onVideoProgress", Arguments.createMap().apply {
+                            putInt("index", index); putInt("total", totalCount); putDouble("progress", progress.toDouble())
+                            putString("processingId", processingId)
+                        })
                     }
-                    
-                    // Load and resize image
-                    contentResolver.openInputStream(uri)?.use { resizedInputStream ->
-                        // Initial decode for sizing
-                        val decodeOptions = BitmapFactory.Options().apply {
-                            inSampleSize = calculateInSampleSize(originalWidth, originalHeight, maxWidth, maxHeight)
-                        }
-                        var bitmap = BitmapFactory.decodeStream(resizedInputStream, null, decodeOptions)
-                        
-                        if (bitmap != null) {
-                            // Apply EXIF Rotation
-                            val matrix = android.graphics.Matrix()
-                            when (orientation) {
-                                android.media.ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
-                                android.media.ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
-                                android.media.ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
-                                android.media.ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.postScale(-1f, 1f)
-                                android.media.ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.postScale(1f, -1f)
-                            }
-                            
-                            if (!matrix.isIdentity) {
-                                val rotatedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
-                                if (rotatedBitmap != bitmap) {
-                                    bitmap.recycle()
-                                    bitmap = rotatedBitmap
-                                }
-                            }
-
-                            // Precise resize if needed
-                            val finalBitmap = if (bitmap.width > maxWidth || bitmap.height > maxHeight) {
-                                resizeBitmap(bitmap, maxWidth, maxHeight)
-                            } else {
-                                bitmap
-                            }
-                            
-                            val processedBitmap = ImageProcessor.applyWatermarkIfNeeded(reactApplicationContext, finalBitmap)
-                            
-                            // Determine format and extension
-                            val compressFormat: Bitmap.CompressFormat
-                            val extension: String
-                            val mimeType: String
-                            
-                            when (outputFormat) {
-                                "png" -> {
-                                    compressFormat = Bitmap.CompressFormat.PNG
-                                    extension = "png"
-                                    mimeType = "image/png"
-                                }
-                                "jpg", "jpeg" -> {
-                                    compressFormat = Bitmap.CompressFormat.JPEG
-                                    extension = "jpg"
-                                    mimeType = "image/jpeg"
-                                }
-                                else -> { // webp
-                                    compressFormat = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
-                                        Bitmap.CompressFormat.WEBP_LOSSY
-                                    } else {
-                                        @Suppress("DEPRECATION")
-                                        Bitmap.CompressFormat.WEBP
-                                    }
-                                    extension = "webp"
-                                    mimeType = "image/webp"
-                                }
-                            }
-
-                            // Save to temporary file
-                            val tempFile = File.createTempFile("turbo_edited_${System.currentTimeMillis()}_", ".$extension", reactApplicationContext.cacheDir)
-                            FileOutputStream(tempFile).use { out ->
-                                processedBitmap.compress(compressFormat, 85, out)
-                            }
-                            // 썸네일: 같은 비트맵(방향·크롭·그리기 반영)에서 — 원본을 다시 읽지 않음
-                            val thumb = thumbnailOptions?.let {
-                                com.rnattachmentkit.PhotoThumbnail.make(processedBitmap, it, reactApplicationContext.cacheDir, currentIndex)
-                            }
-                            
-                            val finalWidth = processedBitmap.width
-                            val finalHeight = processedBitmap.height
 
-                            // Cleanup
-                            if (bitmap != processedBitmap) {
-                                bitmap.recycle()
-                            }
-                            if (finalBitmap != processedBitmap && finalBitmap != bitmap) {
-                                finalBitmap.recycle()
-                            }
-                            processedBitmap.recycle()
-                            
-                            val createImageInfo = {
-                                WritableNativeMap().apply {
-                                    putString("uri", Uri.fromFile(tempFile).toString())
-                                    putInt("width", finalWidth)
-                                    putInt("height", finalHeight)
-                                    putString("type", mimeType)
-                                    putString("fileName", tempFile.name)
-                                    putString("fileExtension", extension)
-                                    putDouble("fileSize", tempFile.length().toDouble())
-                                    putString("originalUri", uri.toString())
-                                    putInt("originalWidth", originalWidth)
-                                    putInt("originalHeight", originalHeight)
-                                    if (thumb != null) {
-                                        putString("thumbnailUri", Uri.fromFile(thumb.file).toString())
-                                        putInt("thumbnailWidth", thumb.width)
-                                        putInt("thumbnailHeight", thumb.height)
-                                        putDouble("thumbnailFileSize", thumb.fileSize.toDouble())
-                                    }
-                                }
-                            }
-                            val imageInfo = createImageInfo()
-                            results.add(imageInfo)
-
-                            try {
-                                val eventMap = WritableNativeMap().apply {
-                                    putInt("total", totalCount)
-                                    putInt("index", currentIndex)
-                                    putString("processingId", processingId)
-                                    putMap("image", createImageInfo())
-                                }
-                                reactApplicationContext.getJSModule(com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                                    .emit("onImageProcessed", eventMap)
-                            } catch (e: Exception) { }
-                        }
+                    override fun onItem(result: com.rnattachmentkit.AttachmentProcessor.Result) {
+                        if (result.isVideo) hud?.let { h -> main.post { h.update(1f, result.index, totalCount) } }
+                        try {
+                            emitter().emit("onImageProcessed", WritableNativeMap().apply {
+                                putInt("total", totalCount); putInt("index", result.index); putMap("image", toWritableMap(result))
+                                putString("processingId", processingId)
+                            })
+                        } catch (_: Exception) {}
                     }
-                }
-                currentIndex++
-            } catch (e: Exception) {
-                currentIndex++
-                // Skip failed images
-                continue
-            }
-        }
-        } catch (e: com.rnattachmentkit.VideoExporter.CancelledException) {
-            // 취소: 지금까지 만든 동영상 파일은 지움
-            videoFiles.forEach { try { it.delete() } catch (_: Exception) {} }
-            throw e
+                }).map { toWritableMap(it) }
         } finally {
             activeProcessingJobs.remove(processingId)
             if (hud != null) withContext(Dispatchers.Main) { hud?.dismiss() }
         }
-
-        results
     }
-    
-    private fun calculateInSampleSize(
-        reqWidth: Int,
-        reqHeight: Int,
-        maxWidth: Int,
-        maxHeight: Int
-    ): Int {
-        var inSampleSize = 1
-        
-        if (reqHeight > maxHeight || reqWidth > maxWidth) {
-            val halfHeight = reqHeight / 2
-            val halfWidth = reqWidth / 2
-            
-            while ((halfHeight / inSampleSize) >= maxHeight && (halfWidth / inSampleSize) >= maxWidth) {
-                inSampleSize *= 2
+
+    /** AttachmentProcessor.Result → RN 결과 맵 (예전 브릿지와 같은 필드·타입) */
+    private fun toWritableMap(r: com.rnattachmentkit.AttachmentProcessor.Result): WritableMap = WritableNativeMap().apply {
+        r.toMap().forEach { (k, v) ->
+            when (v) {
+                is Boolean -> putBoolean(k, v)
+                is Int -> putInt(k, v)
+                is Number -> putDouble(k, v.toDouble())
+                else -> putString(k, v.toString())
             }
         }
-        
-        return inSampleSize
-    }
-    
-    private fun resizeBitmap(bitmap: Bitmap, maxWidth: Int, maxHeight: Int): Bitmap {
-        val width = bitmap.width
-        val height = bitmap.height
-        
-        val ratioBitmap = width.toFloat() / height.toFloat()
-        val ratioMax = maxWidth.toFloat() / maxHeight.toFloat()
-        
-        var finalWidth = maxWidth
-        var finalHeight = maxHeight
-        
-        if (ratioMax > ratioBitmap) {
-            finalWidth = (maxHeight * ratioBitmap).toInt()
-        } else {
-            finalHeight = (maxWidth / ratioBitmap).toInt()
-        }
-        
-        return Bitmap.createScaledBitmap(bitmap, finalWidth, finalHeight, true)
     }