react-native-attachment-kit 1.0.2 → 1.0.6

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

@@ -39,6 +39,33 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
     private var maxWidth: Int = 1024
     private var maxHeight: Int = 1024
     private var outputFormat: String = "webp" // Default to webp
+    // ─── 동영상 (openGallery mediaType / video 옵션) ───
+    private var mediaType: String = "photo"
+    private var videoOptions = com.rnattachmentkit.VideoExportOptions()
+    /** onSelectionChange 에 실어 보낼 maxSelection (예전엔 10 고정) */
+    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 가 없을 때) */
+    @Volatile private var lastProcessingId: String? = null
+
+    /** 보낸 순간의 설정 — 처리 중에 갤러리를 다시 열면 모듈 필드가 새 호출 값으로 바뀌므로, 처리는 이 사본만 씀 */
+    private class SendSnapshot(
+        val maxWidth: Int, val maxHeight: Int, val outputFormat: String,
+        val videoOptions: com.rnattachmentkit.VideoExportOptions,
+        val states: Map<String, com.rnattachmentkit.VideoEditState>,
+        val showHUD: Boolean, val themeColor: Int?, val language: String
+    )
+    private fun sendSnapshot() = SendSnapshot(maxWidth, maxHeight, outputFormat, videoOptions, HashMap(lastVideoEditStates),
+        showVideoHUD, lastThemeColorInt, lastLanguageCode)
+    /** 동영상 변환 진행 HUD — video.showProgressHUD, 없으면 asyncProcessing 이 아닐 때만 (이벤트로 말풍선에 그리는 앱은 HUD 없이) */
+    private var showVideoHUD = true
+    /** 시트가 닫힐 때 넘겨받은 동영상 편집 상태 (원본 uri 문자열 → 품질·음소거) */
+    private var lastVideoEditStates: Map<String, com.rnattachmentkit.VideoEditState> = emptyMap()
 
     @ReactMethod
     fun addListener(eventName: String) {
@@ -255,6 +282,22 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
             false
         }
 
+        // 동영상: mediaType "photo"(기본) | "video" | "all", video: VideoOptions
+        mediaType = (if (options.hasKey("mediaType") && !options.isNull("mediaType")) options.getString("mediaType") else null)
+            ?.lowercase()?.takeIf { it == "video" || it == "all" } ?: "photo"
+        videoOptions = com.rnattachmentkit.VideoExportOptions.fromMap(
+            if (options.hasKey("video") && !options.isNull("video")) options.getMap("video")?.toHashMap() else null
+        )
+        run {
+            val async = options.hasKey("asyncProcessing") && !options.isNull("asyncProcessing") && options.getBoolean("asyncProcessing")
+            val v = if (options.hasKey("video") && !options.isNull("video")) options.getMap("video") else null
+            showVideoHUD = if (v != null && v.hasKey("showProgressHUD") && !v.isNull("showProgressHUD")) v.getBoolean("showProgressHUD") else !async
+        }
+        lastMaxSelection = maxSelection
+        TurboImagePickerConfig.videoOptions = videoOptions
+        lastLanguageCode = languageCode
+        lastThemeColorInt = try { themeColor?.let { android.graphics.Color.parseColor(it) } } catch (_: Exception) { null }
+
         val fragmentActivity = activity as? FragmentActivity
         if (fragmentActivity == null) {
             promise.reject(E_NO_ACTIVITY, "Activity is not a FragmentActivity")
@@ -262,31 +305,107 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
         }
 
         pickImagesPromise = promise
+        // 이번 호출의 promise 를 붙잡아 둠 — 리스너가 모듈 필드를 읽으면, 시트가 열린 채 openGallery 를 다시 불렀을 때
+        // 이전 시트가 치워지며 오는 onDismiss 가 "새" promise 를 거부해 버림. 시트마다 자기 promise 를 한 번만 끝냄
+        val thisPromise = promise
+        var settled = false
+        val settle: ((Promise) -> Unit) -> Unit = { block ->
+            if (!settled) {
+                settled = true
+                if (pickImagesPromise === thisPromise) pickImagesPromise = null
+                block(thisPromise)
+            }
+        }
+        // 지난 호출이 남긴 오래된 임시 파일(24시간 지난 것) 정리 — 백그라운드
+        moduleScope.launch(Dispatchers.IO) {
+            try { TempFileCleaner.cleanStale(reactApplicationContext) } catch (_: Exception) {}
+        }
 
         val permission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
             Manifest.permission.READ_MEDIA_IMAGES
         } else {
             Manifest.permission.READ_EXTERNAL_STORAGE
         }
+        // Android 13+ 에서 동영상도 보이면 READ_MEDIA_VIDEO 를 같이 요청
+        val mediaPermissions: Array<String> = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && mediaType != "photo") {
+            arrayOf(Manifest.permission.READ_MEDIA_IMAGES, Manifest.permission.READ_MEDIA_VIDEO)
+        } else {
+            arrayOf(permission)
+        }
 
         val showSheet = {
             fragmentActivity.runOnUiThread {
                 try {
                     val bottomSheet = ImagePickerBottomSheet.newInstance(
                         maxSelection, languageCode, enableEditor, profileMode, maxWidth, maxHeight, themeColor,
-                        forceMultiMode = forceMultiMode
+                        forceMultiMode = forceMultiMode,
+                        // 첨부 메뉴(갤러리 / 위치 / 파일). 기본 false — 켜지 않으면 기존과 같음
+                        showAttachMenu = options.hasKey("showAttachMenu") && options.getBoolean("showAttachMenu"),
+                        // (Android) 첨부 메뉴 바 아래 여백 (dp). 없으면 기본 12 / 8
+                        attachMenuSinkIntoNav = if (options.hasKey("attachMenuSinkIntoNav") && !options.isNull("attachMenuSinkIntoNav"))
+                            options.getDouble("attachMenuSinkIntoNav").toFloat() else com.rnattachmentkit.AttachMenuBarView.SINK_INTO_NAV_DP.toFloat(),
+                        attachMenuMinBottomMargin = if (options.hasKey("attachMenuMinBottomMargin") && !options.isNull("attachMenuMinBottomMargin"))
+                            options.getDouble("attachMenuMinBottomMargin").toFloat() else com.rnattachmentkit.AttachMenuBarView.BOTTOM_MARGIN_DP.toFloat(),
+                        // 위치 보내기 때 지도 이미지 캡처 여부. 기본 true (기존 그대로). false 면 이미지 없이 위치 정보만
+                        captureLocationImage = !(options.hasKey("captureLocationImage") && !options.isNull("captureLocationImage")) ||
+                            options.getBoolean("captureLocationImage"),
+                        // 동영상 (mediaType "video"/"all" 일 때 그리드에 동영상, 길이 제한)
+                        mediaType = mediaType,
+                        maxVideoDurationSec = videoOptions.maxDurationSec
                     )
+                    // 위치 탭에서 보내기 → onLocationSelected 이벤트로 결과를 넘기고, openGallery 는 빈 배열로 끝냄
+                    bottomSheet.setOnLocationSelectedListener { loc ->
+                        val body = com.facebook.react.bridge.Arguments.createMap()
+                        for ((k, v) in loc) {
+                            when (v) {
+                                is Int -> body.putInt(k, v)
+                                is Long -> body.putDouble(k, v.toDouble())
+                                is Double -> body.putDouble(k, v)
+                                is Float -> body.putDouble(k, v.toDouble())
+                                is Boolean -> body.putBoolean(k, v)
+                                is String -> body.putString(k, v)
+                            }
+                        }
+                        emitGalleryEvent("onLocationSelected", body)
+                        settle { it.resolve(com.facebook.react.bridge.Arguments.createArray()) }
+                    }
+                    // 파일 탭에서 보내기 → onFilesSelected 이벤트 { files: [{uri, path, name, size, mimeType}], failed: [{name, error}] }, openGallery 는 빈 배열
+                    bottomSheet.setOnFilesResultListener { files, failed ->
+                        val arr = com.facebook.react.bridge.Arguments.createArray()
+                        for (file in files) {
+                            val m = com.facebook.react.bridge.Arguments.createMap()
+                            for ((k, v) in file) {
+                                when (v) {
+                                    is Double -> m.putDouble(k, v)
+                                    is String -> m.putString(k, v)
+                                }
+                            }
+                            arr.pushMap(m)
+                        }
+                        val body = com.facebook.react.bridge.Arguments.createMap()
+                        body.putArray("files", arr)
+                        // 복사에 실패한 파일 (추가 필드 — files 는 예전과 같음)
+                        val failedArr = com.facebook.react.bridge.Arguments.createArray()
+                        for (f in failed) {
+                            val m = com.facebook.react.bridge.Arguments.createMap()
+                            m.putString("name", f["name"]?.toString() ?: "")
+                            m.putString("error", f["error"]?.toString() ?: "")
+                            failedArr.pushMap(m)
+                        }
+                        body.putArray("failed", failedArr)
+                        emitGalleryEvent("onFilesSelected", body)
+                        settle { it.resolve(com.facebook.react.bridge.Arguments.createArray()) }
+                    }
                     bottomSheet.setOnImagesSelectedListener { uris ->
+                        lastVideoEditStates = HashMap(bottomSheet.videoEditStates)
                         val result = WritableNativeArray()
                         for (uri in uris) {
                             result.pushString(uri.toString())
                         }
-                        handleSelectedImages(result, pickImagesPromise)
-                        pickImagesPromise = null
+                        settle { handleSelectedImages(result, it) }
                     }
                     bottomSheet.setOnCancelledListener {
-                        pickImagesPromise?.reject(E_PICKER_CANCELLED, "User cancelled image picker")
-                        pickImagesPromise = null
+                        settle { it.reject(E_PICKER_CANCELLED, "User cancelled image picker") }
                     }
                     
                     val existingFragment = fragmentActivity.supportFragmentManager.findFragmentByTag("ImagePickerBottomSheet")
@@ -299,13 +418,12 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                         .commitAllowingStateLoss()
                         
                 } catch (e: Exception) {
-                    pickImagesPromise?.reject(E_FAILED_TO_PICK, "Failed to open image picker: ${e.message}", e)
-                    pickImagesPromise = null
+                    settle { it.reject(E_FAILED_TO_PICK, "Failed to open image picker: ${e.message}", e) }
                 }
             }
         }
 
-        if (ContextCompat.checkSelfPermission(fragmentActivity, permission) == PackageManager.PERMISSION_GRANTED) {
+        if (mediaPermissions.all { ContextCompat.checkSelfPermission(fragmentActivity, it) == PackageManager.PERMISSION_GRANTED }) {
             showSheet()
         } else {
             val permissionAwareActivity = fragmentActivity as? PermissionAwareActivity
@@ -320,28 +438,25 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                     showSheet()
                     return
                 }
-                arrayOf(Manifest.permission.READ_MEDIA_IMAGES, Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+                mediaPermissions + Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED
             } else {
-                arrayOf(permission)
+                mediaPermissions
             }
 
             permissionAwareActivity.requestPermissions(permissionsToRequest, 100, object : PermissionListener {
                 override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray): Boolean {
                     if (requestCode == 100 && grantResults != null) {
                         val isGranted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                            grantResults.isNotEmpty() && (
-                                grantResults[0] == PackageManager.PERMISSION_GRANTED || 
-                                (grantResults.size > 1 && grantResults[1] == PackageManager.PERMISSION_GRANTED)
-                            )
+                            // 14+: 전체 허용이든 "일부 선택"이든 하나라도 허용이면 진행
+                            grantResults.any { it == PackageManager.PERMISSION_GRANTED }
                         } else {
-                            grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED
+                            grantResults.isNotEmpty() && grantResults.all { it == PackageManager.PERMISSION_GRANTED }
                         }
 
                         if (isGranted) {
                             showSheet()
                         } else {
-                            pickImagesPromise?.reject("E_PERMISSION_DENIED", "Permission denied")
-                            pickImagesPromise = null
+                            settle { it.reject("E_PERMISSION_DENIED", "Permission denied") }
                         }
                     }
                     return true
@@ -398,6 +513,15 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
         promise.resolve(null)
     }
 
+    /** 동영상 변환 취소 (HUD 없이 앱이 말풍선에서). index -1 = 남은 동영상 전부. 진행 중인 처리가 없으면 false */
+    @ReactMethod
+    fun cancelVideoProcessing(index: Double, processingId: String, promise: Promise) {
+        val job = (processingId.ifEmpty { lastProcessingId })?.let { activeProcessingJobs[it] }
+        if (job == null) { promise.resolve(false); return }
+        job.cancel(if (index >= 0) index.toInt() else null)
+        promise.resolve(true)
+    }
+
     @ReactMethod
     override fun closeGallery(promise: Promise) {
         val currentActivity = currentActivity
@@ -536,6 +660,22 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                             putStringArrayList("placeholderImages", placeholders)
                         }
                     }
+                    // 동영상 페이지 (뷰어 동영상 작업 지시서 V1): videos[i] = { uri, cacheFile? } 또는 null(사진).
+                    // images[i] 는 그 동영상의 포스터. 이 오버레이 뷰어에서만 재생합니다.
+                    if (options.hasKey("videos")) {
+                        val videoArray = options.getArray("videos")
+                        if (videoArray != null) {
+                            val uris = ArrayList<String>()
+                            val caches = ArrayList<String>()
+                            for (i in 0 until videoArray.size()) {
+                                val m = if (videoArray.getType(i) == com.facebook.react.bridge.ReadableType.Map) videoArray.getMap(i) else null
+                                uris.add(if (m != null && m.hasKey("uri") && !m.isNull("uri")) m.getString("uri") ?: "" else "")
+                                caches.add(if (m != null && m.hasKey("cacheFile") && !m.isNull("cacheFile")) m.getString("cacheFile") ?: "" else "")
+                            }
+                            putStringArrayList(com.rnattachmentkit.ViewerVideoSource.ARG_URIS, uris)
+                            putStringArrayList(com.rnattachmentkit.ViewerVideoSource.ARG_CACHE_FILES, caches)
+                        }
+                    }
                     // 상단바 저장/공유/삭제 버튼과 그 문구들 (iOS와 동일한 옵션 키). 문구를 안 넘기면
                     // 네이티브 쪽 로케일 리소스(values-ko/ja/zh, 그 외 en)가 자동 적용됩니다.
                     putBoolean("showActionButtons", !options.hasKey("showActionButtons") || options.getBoolean("showActionButtons"))
@@ -728,9 +868,10 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                 return
             }
 
+            val snap = sendSnapshot()
             moduleScope.launch {
                 try {
-                    val results = processImages(uris)
+                    val results = processImages(uris, snap)
                     if (results.isNotEmpty()) {
                         promise.resolve(results[0])
                     } else {
@@ -774,7 +915,7 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
         // Process images asynchronously
         val eventMap = com.facebook.react.bridge.WritableNativeMap()
         eventMap.putInt("selectedCount", uris.size)
-        eventMap.putInt("maxSelection", 10)
+        eventMap.putInt("maxSelection", lastMaxSelection)
         try {
             reactApplicationContext.getJSModule(com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                 .emit("onSelectionChange", eventMap)
@@ -782,25 +923,183 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
             // Ignore
         }
 
+        val snap = sendSnapshot()
         moduleScope.launch {
             try {
-                val results = processImages(uris)
+                val results = processImages(uris, snap)
                 val array = com.facebook.react.bridge.Arguments.createArray()
                 results.forEach { array.pushMap(it) }
                 actualPromise.resolve(array)
+            } catch (e: com.rnattachmentkit.VideoExporter.CancelledException) {
+                actualPromise.reject("CANCELLED", "Video export cancelled")
             } catch (e: Exception) {
                 actualPromise.reject(E_FAILED_TO_PICK, "Failed to process images: ${e.message}", e)
             }
         }
     }
 
-    private suspend fun processImages(uris: List<Uri>): List<com.facebook.react.bridge.WritableMap> = withContext(Dispatchers.IO) {
+    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 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 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) {
+            withContext(Dispatchers.Main) {
+                val act = getCurrentActivity() ?: return@withContext
+                hud = com.rnattachmentkit.VideoExportHUD(act, lastThemeColorInt, lastLanguageCode).also { h ->
+                    h.onCancel = {
+                        videoCancelled = true
+                        currentVideoExporter?.cancel()
+                    }
+                    h.show()
+                }
+            }
+        }
+        val videoFiles = mutableListOf<File>()
+
+        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")
+                        }
+                    }
+                } 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)
+                            putString("processingId", processingId)
+                        })
+                } catch (_: Exception) {}
+                currentIndex++
+                continue
+            }
             try {
                 // 1. Get EXIF Orientation
                 var orientation = android.media.ExifInterface.ORIENTATION_NORMAL
@@ -931,6 +1230,7 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                                 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)
@@ -946,6 +1246,14 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                 continue
             }
         }
+        } catch (e: com.rnattachmentkit.VideoExporter.CancelledException) {
+            // 취소: 지금까지 만든 동영상 파일은 지움
+            videoFiles.forEach { try { it.delete() } catch (_: Exception) {} }
+            throw e
+        } finally {
+            activeProcessingJobs.remove(processingId)
+            if (hud != null) withContext(Dispatchers.Main) { hud?.dismiss() }
+        }
 
         results
     }
@@ -1142,4 +1450,267 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
             .unregisterReceiver(imageDeletedReceiver)
     }
 
+    // ── 지도 뷰어 (위치 메시지 → 지도) ──
+
+    private var mapViewer: java.lang.ref.WeakReference<MapViewerDialogFragment>? = null
+    /** updateMapViewerSourceRect 로 갱신되는 닫힘 위치 (화면 px) */
+    @Volatile private var mapViewerSourceRect: android.graphics.Rect? = null
+
+    /** RN measureInWindow 값(dp, 창 기준) → 화면 px Rect */
+    private fun mapRectFromDp(map: ReadableMap?, activity: Activity): android.graphics.Rect? {
+        if (map == null || !map.hasKey("x") || !map.hasKey("y") || !map.hasKey("width") || !map.hasKey("height")) return null
+        val w = com.facebook.react.uimanager.PixelUtil.toPixelFromDIP(map.getDouble("width").toFloat())
+        val h = com.facebook.react.uimanager.PixelUtil.toPixelFromDIP(map.getDouble("height").toFloat())
+        if (w <= 0f || h <= 0f) return null
+        val loc = IntArray(2)
+        try { activity.window?.decorView?.getLocationOnScreen(loc) } catch (_: Exception) {}
+        val x = com.facebook.react.uimanager.PixelUtil.toPixelFromDIP(map.getDouble("x").toFloat()) + loc[0]
+        val y = com.facebook.react.uimanager.PixelUtil.toPixelFromDIP(map.getDouble("y").toFloat()) + loc[1]
+        return android.graphics.Rect(Math.round(x), Math.round(y), Math.round(x + w), Math.round(y + h))
+    }
+
+    /** 말풍선 이미지 → 로컬 파일 경로. file:// 는 그대로, http(s) 는 Glide 캐시 파일. 실패·지연 시 null (이미지 없이 엶) */
+    private fun mapSourceImagePath(uri: String?): String? {
+        if (uri.isNullOrBlank()) return null
+        if (uri.startsWith("/")) return uri.takeIf { File(it).exists() }
+        if (uri.startsWith("file://")) return Uri.parse(uri).path?.takeIf { File(it).exists() }
+        if (!uri.startsWith("http://") && !uri.startsWith("https://")) return null
+        return try {
+            com.bumptech.glide.Glide.with(reactApplicationContext.applicationContext)
+                .downloadOnly().load(uri).submit()
+                .get(1500, java.util.concurrent.TimeUnit.MILLISECONDS)
+                ?.absolutePath
+        } catch (e: Exception) {
+            android.util.Log.w("RNAttachmentKit", "openMapViewer: source image not loaded (${e.javaClass.simpleName})")
+            null
+        }
+    }
+
+    @ReactMethod
+    fun openMapViewer(options: ReadableMap, promise: Promise) {
+        val activity = getCurrentActivity() as? FragmentActivity
+        if (activity == null) {
+            promise.reject("NO_ACTIVITY", "Activity is not a FragmentActivity")
+            return
+        }
+        if (!options.hasKey("latitude") || !options.hasKey("longitude")) {
+            promise.reject("ERROR", "latitude and longitude are required")
+            return
+        }
+        fun str(key: String) = if (options.hasKey(key) && !options.isNull(key)) options.getString(key) else null
+        fun num(key: String) = if (options.hasKey(key) && !options.isNull(key)) options.getDouble(key) else null
+        val lat = options.getDouble("latitude")
+        val lng = options.getDouble("longitude")
+        val rect = mapRectFromDp(if (options.hasKey("sourceRect") && !options.isNull("sourceRect")) options.getMap("sourceRect") else null, activity)
+        val imageUri = str("sourceImageUri")
+        val themeColor = str("themeColor")?.let { try { android.graphics.Color.parseColor(it) } catch (_: Exception) { null } }
+        val radiusPx = com.facebook.react.uimanager.PixelUtil.toPixelFromDIP((num("sourceCornerRadius") ?: 12.0).toFloat())
+        val showDirections = if (options.hasKey("showDirections") && !options.isNull("showDirections")) options.getBoolean("showDirections") else true
+
+        CoroutineScope(Dispatchers.IO).launch {
+            val imagePath = if (rect != null) mapSourceImagePath(imageUri) else null
+            withContext(Dispatchers.Main) {
+                if (activity.isFinishing || activity.isDestroyed || activity.supportFragmentManager.isStateSaved) {
+                    promise.reject("ERROR", "Activity is not available")
+                    return@withContext
+                }
+                try {
+                    mapViewerSourceRect = rect
+                    val f = MapViewerDialogFragment.show(
+                        activity, lat, lng,
+                        title = str("title"),
+                        address = str("address"),
+                        markerType = str("markerType"),
+                        themeColor = themeColor,
+                        languageCode = str("languageCode") ?: "en",
+                        showDirections = showDirections,
+                        sourceRect = rect,
+                        sourceImagePath = imagePath,
+                        sourceCornerRadius = radiusPx,
+                        spanMeters = num("spanMeters") ?: 0.0,
+                        appearance = str("appearance"),
+                        addressLanguageCode = str("addressLanguageCode"),
+                    )
+                    if (rect != null) f.sourceRectProvider = { mapViewerSourceRect }
+                    var settled = false
+                    f.onWillClose = { ms ->
+                        try {
+                            reactApplicationContext
+                                .getJSModule(com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                .emit("onMapViewerWillClose", com.facebook.react.bridge.Arguments.createMap().apply { putInt("durationMs", ms) })
+                        } catch (_: Exception) {}
+                    }
+                    f.onClosed = {
+                        if (!settled) { settled = true; promise.resolve(null) }
+                        mapViewerSourceRect = null
+                        mapViewer = null
+                    }
+                    mapViewer = java.lang.ref.WeakReference(f)
+                } catch (e: Exception) {
+                    promise.reject("ERROR", e.message, e)
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun updateMapViewerSourceRect(rect: ReadableMap, promise: Promise) {
+        val activity = getCurrentActivity()
+        if (mapViewer?.get() != null && activity != null) mapViewerSourceRect = mapRectFromDp(rect, activity)
+        promise.resolve(null)
+    }
+
+    /**
+     * 위치 메시지 지도 썸네일을 이 기기에서 그림 (테마별 캐시). 결과 { uri, path, width, height(px), cached }
+     * options: latitude, longitude, width, height (dp, 필수) / markerType, placeCategory, spanMeters, themeColor,
+     *          appearance ("light"/"dark"/"system"), myLatitude + myLongitude (둘 다 있을 때만)
+     * aspect ("square" | "portrait" | "device"): 주면 width 만 필수, height 는 비율로 (square = 1:1,
+     *          portrait = 480:1040 보내던 이미지와 같은 9:19.5, device = 실제 화면 긴 변/짧은 변). 모르는 값이면 없는 것과 같음
+     * maxWidth / maxHeight (px, 기본 512, 0 이하면 무시): 출력 WebP 가 이 안에 들어가게 비율대로 줄임
+     *          (k = min(density, maxWidth / widthDp, maxHeight / heightDp)) → 결과 width/height 는 출력 px
+     */
+    @ReactMethod
+    fun renderLocationThumbnail(options: ReadableMap, promise: Promise) {
+        fun str(key: String) = if (options.hasKey(key) && !options.isNull(key)) options.getString(key) else null
+        fun num(key: String) = if (options.hasKey(key) && !options.isNull(key)) options.getDouble(key) else null
+        val lat = num("latitude")
+        val lng = num("longitude")
+        val wDp = num("width")
+        val activity = getCurrentActivity()
+        val aspectRatio: Double? = when (str("aspect")?.lowercase()) {
+            "square" -> 1.0
+            "portrait" -> 1040.0 / 480.0
+            "device" -> {
+                // 실제 화면 크기 (세로 기준: 긴 변 / 짧은 변 → h > w)
+                val dm = (activity ?: reactApplicationContext).resources.displayMetrics
+                var sw = dm.widthPixels; var sh = dm.heightPixels
+                if (activity != null && android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+                    try {
+                        val b = activity.windowManager.currentWindowMetrics.bounds
+                        if (b.width() > 0 && b.height() > 0) { sw = b.width(); sh = b.height() }
+                    } catch (_: Exception) {}
+                }
+                val lo = minOf(sw, sh); val hi = maxOf(sw, sh)
+                if (lo > 0) hi.toDouble() / lo else 19.5 / 9.0
+            }
+            else -> null
+        }
+        val hDp = if (aspectRatio != null) wDp?.let { it * aspectRatio } else num("height")
+        if (lat == null || lng == null || wDp == null || hDp == null || wDp <= 0 || hDp <= 0 ||
+            lat.isNaN() || lng.isNaN()) {
+            promise.reject("E_INVALID_ARGS", "latitude, longitude, width, height (> 0) are required")
+            return
+        }
+        val myLat = num("myLatitude")
+        val myLng = num("myLongitude")
+        if ((myLat == null) != (myLng == null)) {
+            promise.reject("E_INVALID_ARGS", "myLatitude and myLongitude must be given together")
+            return
+        }
+        if (activity == null) {
+            promise.reject(E_NO_ACTIVITY, "Activity doesn't exist")
+            return
+        }
+        val accent = str("themeColor")?.let { try { android.graphics.Color.parseColor(it) } catch (_: Exception) { null } }
+            ?: android.graphics.Color.parseColor("#FF6B35")
+        val dark = when (str("appearance")?.lowercase()) {
+            "dark" -> true
+            "light" -> false
+            else -> (activity.resources.configuration.uiMode and android.content.res.Configuration.UI_MODE_NIGHT_MASK) ==
+                android.content.res.Configuration.UI_MODE_NIGHT_YES
+        }
+        val wPx = Math.round(com.facebook.react.uimanager.PixelUtil.toPixelFromDIP(wDp.toFloat())).coerceAtLeast(1)
+        val hPx = Math.round(com.facebook.react.uimanager.PixelUtil.toPixelFromDIP(hDp.toFloat())).coerceAtLeast(1)
+        val maxOutW = num("maxWidth")?.takeIf { it > 0 }?.let { Math.round(it).toInt() }
+        val maxOutH = num("maxHeight")?.takeIf { it > 0 }?.let { Math.round(it).toInt() }
+        val req = LocationThumbnailRenderer.Request(
+            lat = lat, lng = lng, widthPx = wPx, heightPx = hPx,
+            density = activity.resources.displayMetrics.density,
+            dark = dark,
+            markerType = str("markerType"),
+            placeCategory = str("placeCategory"),
+            spanMeters = num("spanMeters"),
+            accent = accent,
+            myLat = myLat, myLng = myLng,
+            // 출력 최대 크기 (0 이하·없음 → 기본 512)
+            // 결과 최대 크기 (px). 둘 다 없으면 512 × 512, 하나만 주면 다른 쪽은 제한 없음(0)
+            maxOutWidthPx = maxOutW ?: if (maxOutH != null) 0 else LocationThumbnailRenderer.DEFAULT_MAX_OUT_PX,
+            maxOutHeightPx = maxOutH ?: if (maxOutW != null) 0 else LocationThumbnailRenderer.DEFAULT_MAX_OUT_PX,
+        )
+        com.facebook.react.bridge.UiThreadUtil.runOnUiThread {
+            try {
+                LocationThumbnailRenderer.render(activity, req) { r ->
+                    r.fold(
+                        onSuccess = { m ->
+                            val body = Arguments.createMap()
+                            body.putString("uri", m["uri"] as? String)
+                            body.putString("path", m["path"] as? String)
+                            body.putInt("width", (m["width"] as? Int) ?: wPx)
+                            body.putInt("height", (m["height"] as? Int) ?: hPx)
+                            body.putBoolean("cached", (m["cached"] as? Boolean) ?: false)
+                            promise.resolve(body)
+                        },
+                        onFailure = { e -> promise.reject("E_THUMBNAIL_FAILED", e.message ?: "Thumbnail render failed", e) }
+                    )
+                }
+            } catch (e: Exception) {
+                promise.reject("E_THUMBNAIL_FAILED", e.message ?: "Thumbnail render failed", e)
+            }
+        }
+    }
+
+    /** 지도 썸네일 캐시 비우기 */
+    @ReactMethod
+    fun clearLocationThumbnailCache(promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try { LocationThumbnailRenderer.clearCache(reactApplicationContext) } catch (_: Exception) {}
+            promise.resolve(null)
+        }
+    }
+
+    // ── AI 기능 설정·잔액 (넘긴 값만 바뀜). 사용·충전 요청은 onAIUsage / onAIChargeRequired 이벤트로 알림 ──
+
+    @ReactMethod
+    fun setAIConfig(config: ReadableMap, promise: Promise) {
+        AIBilling.apply(config.toHashMap())
+        val ctx = reactApplicationContext
+        fun emit(name: String, body: Map<String, Any>) {
+            // 앱이 내려가는 중이면 조용히 무시
+            runCatching {
+                ctx.getJSModule(com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit(name, com.facebook.react.bridge.Arguments.makeNativeMap(body))
+            }
+        }
+        AIBilling.onUsage = { emit("onAIUsage", it) }
+        AIBilling.onChargeRequired = { emit("onAIChargeRequired", it) }
+        promise.resolve(null)
+    }
+
+    // ── 역지오코딩 (기기 Geocoder, 디스크 캐시) ──
+
+    @ReactMethod
+    fun reverseGeocode(options: ReadableMap, promise: Promise) {
+        val lat = if (options.hasKey("latitude") && !options.isNull("latitude")) options.getDouble("latitude") else Double.NaN
+        val lng = if (options.hasKey("longitude") && !options.isNull("longitude")) options.getDouble("longitude") else Double.NaN
+        val lang = if (options.hasKey("languageCode") && !options.isNull("languageCode")) options.getString("languageCode") else null
+        ReverseGeocoder.reverseGeocode(reactApplicationContext, lat, lng, lang) { r, e ->
+            if (r != null) {
+                val map = Arguments.createMap()
+                r.address?.let { map.putString("address", it) } ?: map.putNull("address")
+                r.shortAddress?.let { map.putString("shortAddress", it) } ?: map.putNull("shortAddress")
+                map.putBoolean("cached", r.cached)
+                promise.resolve(map)
+            } else {
+                promise.reject(e?.code ?: "E_GEOCODE_FAILED", e?.message ?: "Reverse geocoding failed")
+            }
+        }
+    }
+
+    @ReactMethod
+    fun clearReverseGeocodeCache(promise: Promise) {
+        CoroutineScope(Dispatchers.IO).launch {
+            try { ReverseGeocoder.clearCache(reactApplicationContext) } catch (_: Exception) {}
+            promise.resolve(null)
+        }
+    }
 }