react-native-attachment-kit 1.0.5 → 1.0.8

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 1.0.8 — 2026-10-16
+
+- **AI screens are the same in every app (iOS + Android)**. Generate: woman / man, country, age (up to the 80s), style, situation, aspect ratio + Create, sample chips and the chat input; chat text is sent together with the chosen settings, and tapping a sample shows a summary of the settings before creating. The glamour situations / samples and the detail options were removed from the generate screen. Edit: the full editing screen everywhere. Generated and edited images are stored for the gallery's "AI 이미지" tab in every app.
+- iOS: the "AI 이미지" tab expands / collapses the sheet like the gallery grid.
+- iOS: an edited (trimmed) video's first poster (`onProcessingStart` `thumbnailUri`) is taken from the trimmed start, with crop and drawing applied.
+- iOS: closing the AI screen right after using a menu no longer leaves a stray button over the gallery.
+- Android image viewer: video controls no longer flash on photo pages while the viewer opens.
+
+## 1.0.6 — 2026-10-14
+
+- **Video in the picker, editor and viewer (iOS + Android)**: `openGallery({ mediaType: "all" | "video", video })` picks videos; the editor gets video pages (trim, mute, quality, crop, drawing/stickers/text, pre-encoding); `openViewer({ images, videos })` plays videos (progress pill, mute/options, remote video cache, pinch zoom). Sending progress is reported as events. `video.posterFormat` (`"webp"` default / `"jpg"`). Video limits are checked before sending.
+- **In-app full-screen camera (iOS + Android)**: photo + hold-to-record video (with lock), ratio menu (꽉 참 / 9:16 / 3:4 / 1:1), resolution HD / FHD (default) / 4K, timer, grid, level, tap focus + exposure, stabilization, 30/60 fps, front screen flash, selfie mirror. The screen stays portrait; captures follow how the phone is held. Default lens 1×, smooth pinch zoom across lenses. The podspec now also links `CoreMotion`.
+- **AI (Gemini) generate / edit**: `setAIConfig(...)`; generation screen, natural-language editing in the editor, recent works. Full features only in licensed (ZemTalk) apps; other apps get chat-only generate/edit.
+- **Gallery attach menu "AI 이미지" tab**: shown when AI-made or AI-edited images exist; opens them in the image viewer (save, share, delete).
+- **Image viewer video controls** readable in light mode (follow the Liquid Glass light/dark state).
+- **Android performance**: the gallery opens without waiting for the camera; the camera cell is no longer rebound on scroll, tab change or editor pull-down; the editor zoom lands exactly on video pages.
+- **iOS**: no empty-cell flash when a gallery photo opens in the editor; the AI images viewer no longer shows a red cell slot while open.
+
 ## 1.0.5 — 2026-10-10
 
 - iOS map viewer: Directions is a menu anchored above the button (the action sheet floated at the top on iOS 26); TMAP added (Korean only, with Kakao Map / Naver Map); cancelling the system "Open in …?" prompt no longer falls through to the web map (which opened the app anyway). Uses `canOpenURL` when the host declares `comgooglemaps`, `kakaomap`, `nmap`, `tmap` in `LSApplicationQueriesSchemes`.

package/README.md

@@ -149,13 +149,16 @@ Opens the gallery bottom sheet. Resolves with the picked images (`[]` when the u
 | `outputFormat` | `'webp' \| 'jpg' \| 'png'` | `'webp'` | Output file format. (Not in the TS type yet — pass it with a cast.) |
 | `themeColor` / `languageCode` / `appearance` | | defaults | Per-call overrides. |
 | `doneButtonText` / `allItemsText` / `selectedItemsText` / `recentsAlbumText` | `string` | translated | Label overrides. |
-| `asyncProcessing` | `boolean` | `false` | Resolve right away and deliver each processed image through `onImageProcessed`. |
+| `asyncProcessing` | `boolean` | `false` | Event-driven sending: each item is delivered through `onImageProcessed` as soon as it is ready (the Promise still resolves with everything at the end), and videos show no progress HUD — draw progress in your own UI. See [Sending progress](#sending-progress-events). |
 | `onSelectionChange` | `(e: SelectionChangeEvent) => void` | — | `{ selectedCount, maxSelection }` on every change. |
-| `onImageProcessed` | `(e) => void` | — | Per image when `asyncProcessing` is on. |
+| `onProcessingStart` | `(e: ProcessingStartEvent) => void` | — | Once, right after Send, before any processing. |
+| `onImageProcessed` | `(e) => void` | — | Per item `{ index, total, image }` as soon as it is ready. |
+| `mediaType` | `'photo' \| 'all' \| 'video'` | `'photo'` | `'all'` mixes photos and videos. |
+| `video` | `VideoOptions` | — | `maxDurationSec`, `maxFileSizeMB`, `qualities`, `defaultQuality`, `codec`, `onProgress`, `showProgressHUD`. |
 | `openDuration` / `closeDuration` | `number` (ms) | native | Animation durations. |
 | `showAttachMenu` … | | | Attach menu options — see [Attach menu](#attach-menu-location--file). |
 
-`mediaType` and `quality` are accepted for compatibility but currently ignored (photos only; output quality is fixed).
+`quality` is accepted for compatibility but currently ignored (output quality is fixed).
 
 #### `ImageResult`
 
@@ -176,6 +179,26 @@ Closes the picker from code. `true` if it was open.
 #### `addSelectionChangeListener(listener): () => void`
 Selection events outside `openGallery`; returns an unsubscribe function.
 
+#### Sending progress (events)
+
+A chat can show every sent item at once and fill it in as it finishes (photos are resized, videos are encoded), the same way for photos and videos:
+
+1. **`onProcessingStart`** `{ total, items }`: once, right after Send. Each item has `index`, `mediaType` (`'image' | 'video'`), `originalUri`, and the expected output `width` / `height` (for the aspect ratio). Videos also have `duration` (seconds, after trim) and `thumbnailUri` / `thumbnailWidth` / `thumbnailHeight` (a poster jpg with crop and drawing applied). Create the placeholders here.
+2. **`onVideoProgress`** `{ index, total, progress }`: video encoding 0…1 (at most every 1% / 0.1 s). Draw a progress ring on that placeholder.
+3. **`onImageProcessed`** `{ index, total, image }`: the item is ready. Replace the placeholder with `image.uri`. A video the app cancelled comes as `{ error: 'CANCELLED', cancelled: true }`; a failed one has `error`.
+
+```ts
+const sub = emitter.addListener('onProcessingStart', ({ items }) => addPlaceholders(items))
+const prog = emitter.addListener('onVideoProgress', ({ index, progress }) => setProgress(index, progress))
+const done = emitter.addListener('onImageProcessed', ({ index, image }) => fillPlaceholder(index, image))
+await AttachmentKit.openGallery({ mediaType: 'all', asyncProcessing: true, enableEditor: true })
+// or pass onProcessingStart / onImageProcessed / video.onProgress as options
+```
+
+- **HUD:** `video.showProgressHUD` sets the full-screen progress HUD. The default is `true`, but `false` when `asyncProcessing: true`.
+- **Cancel:** without the HUD, cancel from your UI with `AttachmentKit.cancelVideoProcessing(index?, processingId?)`. No `index` cancels all remaining videos; no `processingId` targets the latest send. The rest keep going, and the cancelled item is reported as above. It returns `false` when nothing is in progress.
+- **Sending again while a video encodes:** the gallery can be opened again as soon as `onProcessingStart` arrives; you don't have to wait for the Promise, which still resolves with everything at the end. Every event carries `processingId`, so an app that listens with global listeners should use it to tell sends apart (`index` restarts at 0 for each send). Callbacks passed in the options are already filtered to their own send.
+
 ---
 
 ### Attach menu (Location / File)
@@ -438,6 +461,80 @@ A native grid built for thousands of photos. It opens like the picker (same bott
 
 ---
 
+### AI (generate & edit)
+
+The gallery's ✦ button (AI image generation) and the editor's 6th tool **AI** (AI photo editing) use Google Gemini. They are **off until you call `setAIConfig({ enabled: true, ... })`**. The screens are the same in every app. Generate has woman / man, country, age, style and situation pickers, an aspect-ratio bar, sample chips and the chat input; chat text is sent together with the chosen settings. Edit is the full editing screen: edit choices, options, recommendation chips and the chat input. Generated and edited images are kept on the device and listed in the gallery's "AI 이미지" tab.
+
+```ts
+await AttachmentKit.setAIConfig({
+  enabled: true,
+  endpoint: "https://api.example.com/ai/generate",   // your server: forwards the Gemini generateContent body with your key
+  headers: { Authorization: `Bearer ${token}` },     // header X-AI-Model carries the model name
+  points: 1200,          // current points
+  freeCount: 27,         // subscribers: free uses left (e.g. 30 per month — your server decides); used before points
+  costPerUse: 100,       // points per use (0 = free / unlimited)
+  highQualityCost: 150,  // points per use with Quality "High (1K)" (default: costPerUse)
+})
+
+const offUsage = AttachmentKit.addAIUsageListener(e => {
+  // { kind: "generate" | "edit", usedFreeCount, pointsDeducted, highQuality, points, freeCount }
+  api.reportAIUsage(e)
+})
+const offCharge = AttachmentKit.addAIChargeRequiredListener(e => {
+  // { kind, required, points, freeCount } — the AI screen has closed
+  AttachmentKit.closeGallery(); navigation.navigate("PointShop")
+})
+```
+
+- Only the values you pass change; call it again whenever the balance changes (after a top-up, after a server sync). An open AI screen updates at once.
+- Order of use: free uses → points → when points are short the user sees "Not enough points · Top up" (Top up → `onAIChargeRequired`, AI screen closes).
+- Only successful requests are charged (failures, cancel and safety blocks are free). The module lowers its own copy and sends `onAIUsage`; your server stays the source of truth.
+- The AI screen title shows "N free left" or "points · cost per use".
+- `apiKey` exists for testing only — never ship a Gemini key in the app.
+
+#### Your backend (the `endpoint`)
+
+The module never needs a Gemini key in the app. Point `endpoint` at **your own server**; it only has to pass the request through to Gemini with your key.
+
+**Request the module sends**
+
+```
+POST {endpoint}
+Content-Type: application/json
+X-AI-Model: gemini-3.1-flash-image        ← model to call (image: gemini-3.1-flash-image / gemini-3.1-flash-lite-image, photo analysis: gemini-3.5-flash-lite)
+…plus every header you passed in setAIConfig({ headers })   ← e.g. Authorization
+
+{ …Gemini generateContent request body… }
+```
+
+**What your server does**
+
+1. Check the user (your `headers`) and that `X-AI-Model` is a model you allow.
+2. Forward the body unchanged to `https://generativelanguage.googleapis.com/v1beta/models/{X-AI-Model}:generateContent` with header `x-goog-api-key: <your key>`.
+3. Return Gemini's status code and JSON body **as is**.
+
+```js
+// Minimal Express example
+app.post('/ai/generate', auth, express.json({ limit: '20mb' }), async (req, res) => {
+  const model = req.get('X-AI-Model');
+  if (!ALLOWED_MODELS.includes(model)) return res.status(400).json({ code: 'MODEL_NOT_ALLOWED' });
+  const r = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'x-goog-api-key': process.env.GEMINI_API_KEY },
+    body: JSON.stringify(req.body),
+  });
+  res.status(r.status).type('application/json').send(await r.text());
+});
+```
+
+**Billing (optional, on your server)** — the module's `points` / `freeCount` are only a display copy. If you charge, do it on the server: reserve before calling Gemini, confirm only when the response contains an image, refund otherwise (failures and safety blocks should be free). Then send the new balance back with `setAIConfig` (e.g. in `addAIUsageListener`).
+
+**Errors** — any status other than 200 is a failed attempt (nothing is deducted in the module). To show your own reason, answer in Gemini's error shape: `{ "error": { "message": "…" } }`. The "Not enough points · Top up" prompt comes from the module's own copy of `points` / `freeCount`, so keep it in sync with `setAIConfig`.
+
+**Security** — keep the key only on the server, allow-list models, limit the body size, and rate-limit per user (photo analysis requests carry no image output and are easy to abuse if left unlimited).
+
+---
+
 ### Misc
 
 | API | Description |

package/android/build.gradle

@@ -112,13 +112,27 @@ if (project != rootProject) {
         // 첨부 메뉴 > 위치 — AAR 내부 의존성은 앱으로 전달되지 않으므로 여기에도 선언 (Glide 와 같은 이유)
         implementation "com.google.android.gms:play-services-maps:19.0.0"
         implementation "com.google.android.gms:play-services-location:21.3.0"
+        // AI 편집: 무료 기기 사진 분석 (얼굴·이미지 라벨). Play 서비스판이라 모델은 기기가 받아 둠 (APK 용량 거의 안 늘어남)
+        implementation "com.google.android.gms:play-services-mlkit-face-detection:17.1.0"
+        implementation "com.google.android.gms:play-services-mlkit-image-labeling:16.0.8"
         
+        // 동영상 (media3 Transformer) — AAR 내부 의존성은 앱으로 전달되지 않으므로 여기에도 선언
+        def media3_version = "1.4.1"
+        implementation "androidx.media3:media3-common:${media3_version}"
+        implementation "androidx.media3:media3-exoplayer:${media3_version}"
+        // 이미지 뷰어 동영상: 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}"
+        implementation "androidx.media3:media3-effect:${media3_version}"
+
         // CameraX dependencies
         def camerax_version = "1.3.1"
         implementation "androidx.camera:camera-core:${camerax_version}"
         implementation "androidx.camera:camera-camera2:${camerax_version}"
         implementation "androidx.camera:camera-lifecycle:${camerax_version}"
         implementation "androidx.camera:camera-view:${camerax_version}"
+        implementation "androidx.camera:camera-video:${camerax_version}"   // 전체 화면 카메라 동영상 녹화
         implementation "androidx.camera:camera-extensions:${camerax_version}"
     }
 }

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

@@ -40,6 +40,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()
 
     // newarch에는 이 맵과 getDefaultAnimationConfig() 구현이 통째로 빠져 있었습니다(oldarch에는 있었음).
     // NativeAttachmentKitSpec(codegen 생성 추상 클래스)이 이 메서드를 abstract로 요구하기 때문에,
@@ -317,6 +344,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")
@@ -345,6 +388,12 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
         } 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 {
@@ -361,7 +410,10 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                             options.getDouble("attachMenuMinBottomMargin").toFloat() else com.rnattachmentkit.AttachMenuBarView.BOTTOM_MARGIN_DP.toFloat(),
                         // 위치 보내기 때 지도 이미지 캡처 여부. 기본 true (기존 그대로). false 면 이미지 없이 위치 정보만
                         captureLocationImage = !(options.hasKey("captureLocationImage") && !options.isNull("captureLocationImage")) ||
-                            options.getBoolean("captureLocationImage")
+                            options.getBoolean("captureLocationImage"),
+                        // 동영상 (mediaType "video"/"all" 일 때 그리드에 동영상, 길이 제한)
+                        mediaType = mediaType,
+                        maxVideoDurationSec = videoOptions.maxDurationSec
                     )
                     // 위치 탭에서 보내기 → onLocationSelected 이벤트로 결과를 넘기고, openGallery 는 빈 배열로 끝냄
                     bottomSheet.setOnLocationSelectedListener { loc ->
@@ -407,6 +459,7 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                         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())
@@ -432,7 +485,7 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
             }
         }
 
-        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
@@ -447,21 +500,19 @@ 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) {
@@ -600,6 +651,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"))
@@ -761,6 +828,14 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    /** 동영상 변환 취소 (HUD 없이 앱이 말풍선에서). index -1 = 남은 동영상 전부. 진행 중인 처리가 없으면 false */
+    override 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)
+    }
+
     override fun closeGallery(promise: Promise) {
         val activity = getCurrentActivity()
         if (activity == null) {
@@ -809,9 +884,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 {
@@ -855,7 +931,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)
@@ -863,25 +939,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
@@ -1012,6 +1246,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)
@@ -1027,6 +1262,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
     }
@@ -1305,6 +1548,13 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
                     )
                     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", Arguments.createMap().apply { putInt("durationMs", ms) })
+                        } catch (_: Exception) {}
+                    }
                     f.onClosed = {
                         if (!settled) { settled = true; promise.resolve(null) }
                         mapViewerSourceRect = null
@@ -1432,6 +1682,23 @@ class RNAttachmentKitModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    // ── AI 기능 설정·잔액 (넘긴 값만 바뀜). 사용·충전 요청은 onAIUsage / onAIChargeRequired 이벤트로 알림 ──
+
+    override 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, 디스크 캐시) ──
 
     override fun reverseGeocode(options: ReadableMap, promise: Promise) {