@pickleball/rtmp-native 0.1.0 → 0.2.0

package/android/src/main/java/expo/modules/pickleballrtmp/PickleballRtmpNativeModule.kt

@@ -1,43 +1,131 @@
 package expo.modules.pickleballrtmp
 
+import android.app.ActivityManager
+import android.app.ApplicationExitInfo
 import android.content.Context
-import android.graphics.Rect
+import android.content.Intent
+import android.content.IntentFilter
+import android.graphics.Bitmap
+import android.graphics.Matrix
 import android.hardware.camera2.CameraCharacteristics
 import android.hardware.camera2.CameraManager
-import android.net.Uri
-import com.haishinkit.media.MediaMixer
-import com.haishinkit.media.source.AudioRecordSource
-import com.haishinkit.media.source.Camera2Source
-import com.haishinkit.stream.StreamSession
-import com.haishinkit.rtmp.RtmpStreamSessionFactory
+import android.hardware.camera2.CameraMetadata
+import android.media.MediaCodec
+import android.os.BatteryManager
+import android.os.Build
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.PowerManager
+import android.util.Base64
+import android.view.PixelCopy
+import android.view.Surface
+import com.pedro.common.ConnectChecker
+import com.pedro.rtmp.rtmp.RtmpClient
 import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.kotlin.records.Field
 import expo.modules.kotlin.records.Record
 import expo.modules.kotlin.exception.CodedException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withTimeoutOrNull
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+import kotlin.coroutines.resume
 
 /**
- * Bản Android của cầu nối deliveryMode="device-rtmp" — song song với
- * ios/PickleballRtmpNativeModule.swift.
+ * Cầu nối deliveryMode="device-rtmp" cho Android.
  *
- * API Kotlin của HaishinKit KHÁC hẳn bản Swift dù cùng tên dự án:
- * MediaMixer nhận Context, attachVideo/attachAudio đặt track TRƯỚC nguồn, và
- * session build() ném lỗi thay vì trả optional. Đừng suy từ file Swift sang.
+ * ===== KIẾN TRÚC (viết lại 2026-08-08) =====
+ *
+ *   Camera2 (1 session, 2 target) ──┬─→ SurfaceView          preview
+ *                                   └─→ MediaCodec Surface ──→ RtmpClient
+ *
+ * KHÔNG có tầng OpenGL nào. Bản cũ đi qua MediaMixer của HaishinKit
+ * (camera → texture OES → compose GL → xuất) và tầng đó là nguồn răng cưa:
+ * `gles/screen/Renderer` đặt GL_TEXTURE_MIN_FILTER = GL_NEAREST và quên
+ * glBindTexture ở nhánh video, `gles/Framebuffer` đặt NEAREST cả MIN lẫn MAG.
+ * Vá cả hai (bản 0.18.2-linear2) vẫn không hết — khuyết tật nằm ở kiến trúc.
+ *
+ * Đo thực nghiệm trên Redmi Note 15, cùng camera cùng cảnh:
+ * Camera2 trần > LiveKit > RootEncoder(full) > HaishinKit. Nên ta dùng Camera2
+ * trần cho hình, và CHỈ mượn module `rtmp` của RootEncoder cho giao thức
+ * đường truyền — không dùng phần camera/GL của nó.
+ *
+ * Hệ quả: toàn bộ reflection của Camera2Controls.kt biến mất (zoom/EV/khoá
+ * nét/khoá sáng/fps/đèn giờ là CaptureRequest key thường vì ta tự sở hữu
+ * session), và không còn hack xoay bằng deviceOrientation.
+ *
+ * GIỚI HẠN CÓ CHỦ Ý: Android chỉ phát khung NGANG. Xoay sang 9:16 đòi hỏi một
+ * bước xoay ảnh — tức đúng tầng GL vừa bỏ. App device-streamer đã khoá
+ * landscape nên không ảnh hưởng; bên nào cần 9:16 phải dùng LiveKit.
  */
 class PickleballRtmpNativeModule : Module() {
-  private var mixer: MediaMixer? = null
-  private var session: StreamSession? = null
-  private var videoSource: Camera2Source? = null
+  private var camera: CameraSession? = null
+  private val video = VideoEncoder()
+  private val audio = AudioEncoder()
+
+  private var rtmp: RtmpClient? = null
   /** Phải khớp mặc định của engine (`isCameraFront: false`) như bên iOS. */
   private var cameraId: String = BACK_DEFAULT_ID
   private var microphoneEnabled = true
   private var publishing = false
+  private var connected = false
+  private var rtmpUrl: String? = null
   private var videoBitrate = 6_000_000
-  /** Luôn giữ dạng NGANG (cạnh dài trước); hướng thật tính ở orientedSize(). */
-  private var videoLongEdge = 1920
-  private var videoShortEdge = 1080
-  private var landscape = true
+  private var audioBitrate = 128_000
+  /** Luôn giữ dạng NGANG (cạnh dài trước). */
+  private var captureWidth = 1920
+  private var captureHeight = 1080
+  private var frameRate = 30
+  /** SPS/PPS lấy từ encoder — RtmpClient cần TRƯỚC khi connect. */
+  private var sps: ByteBuffer? = null
+  private var pps: ByteBuffer? = null
+
+  /**
+   * Mốc PTS đầu của MỖI kết nối RTMP — trừ đi để luồng bắt đầu từ ~0. Nguồn
+   * PTS thô là đồng hồ nội bộ máy (camera timestamp / System.nanoTime), hai
+   * track hai đồng hồ KHÁC nhau: đo 26/08 video mở màn ở 10,86 GIỜ còn audio
+   * 26,5 giờ — player hiện timecode 10 tiếng. Reset mỗi connect() để lần quay
+   * số lại cũng sạch (ingest xử discontinuity sẵn).
+   */
+  @Volatile private var videoPtsBaseUs = -1L
+  @Volatile private var audioPtsBaseUs = -1L
+
+  /** State controls đã chọn — camera mở lại (đổi lens) là reset nên áp lại. */
+  private var zoomRatio: Float? = null
+  private var exposureBiasEv: Float? = null
+  private var focusLocked = false
+  private var exposureLocked = false
+  private var torchEnabled = false
+  private var antibandingMode: Int? = null
+
+  /** Overlay tĩnh (composite/logo đã nướng) + các lớp động — như bên iOS. */
+  private var overlayLogoSpec: OverlayLogoOptions? = null
+  private var overlayAnimatedSpecs: List<OverlayAnimatedOptions> = emptyList()
+  /** Lớp CHỮ đã điền sẵn (tỉ số/tên đội) — cập nhật ~2 lần/phút theo pha bóng. */
+  private var overlayTextSpecs: List<OverlayTextOptions> = emptyList()
+  /** Pass GL — CHỈ tồn tại khi có overlay; null = đường addTarget thẳng như cũ. */
+  private var compositor: GlCompositor? = null
+
+  private val hasOverlay: Boolean
+    get() =
+      overlayLogoSpec != null || overlayAnimatedSpecs.isNotEmpty() || overlayTextSpecs.isNotEmpty()
+
+  private val bandwidthScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+  /** Dựng lại camera khi surface preview đổi — tách scope để không đụng bandwidth. */
+  private val reattachScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+  private var bandwidthJob: Job? = null
+  private var copyThread: HandlerThread? = null
+  /** Surface preview đang nằm trong capture session hiện tại (null = chưa gắn). */
+  private var attachedPreview: Surface? = null
 
   private val context: Context
     get() = appContext.reactContext ?: throw RtmpException("thiếu Android context")
@@ -86,7 +174,7 @@ class PickleballRtmpNativeModule : Module() {
     AsyncFunction("setMicrophoneEnabled") Coroutine { enabled: Boolean ->
       microphoneEnabled = enabled
       // Gỡ hẳn nguồn audio thay vì mute — mic tắt thì không encode luôn.
-      mixer?.attachAudio(0, if (enabled) AudioRecordSource(context) else null)
+      if (enabled) startAudioIfNeeded() else audio.release()
       Unit
     }
 
@@ -94,184 +182,816 @@ class PickleballRtmpNativeModule : Module() {
       applyVideoBitrate(bitsPerSecond)
     }
 
+    // ===== Camera controls =====
+    // Không còn reflection: ta sở hữu CaptureRequest.Builder nên đây là key thường.
+
+    AsyncFunction("getCameraCapabilities") Coroutine { ->
+      cameraCapabilities()
+    }
+
+    AsyncFunction("setZoom") Coroutine { factor: Double ->
+      zoomRatio = factor.toFloat()
+      val active = camera ?: throw RtmpException("chưa có camera — gọi prepare() trước")
+      if (!active.setZoom(factor.toFloat())) {
+        throw RtmpException("thiết bị không hỗ trợ zoom")
+      }
+    }
+
+    AsyncFunction("setExposureBias") Coroutine { ev: Double ->
+      exposureBiasEv = ev.toFloat()
+      val active = camera ?: throw RtmpException("chưa có camera — gọi prepare() trước")
+      if (!active.setExposureBias(ev.toFloat())) {
+        throw RtmpException("thiết bị không hỗ trợ chỉnh EV")
+      }
+    }
+
+    AsyncFunction("setFocusLocked") Coroutine { locked: Boolean ->
+      focusLocked = locked
+      val active = camera ?: throw RtmpException("chưa có camera — gọi prepare() trước")
+      if (!active.setFocusLocked(locked)) throw RtmpException("thiết bị không hỗ trợ khoá nét")
+    }
+
+    AsyncFunction("setExposureLocked") Coroutine { locked: Boolean ->
+      exposureLocked = locked
+      val active = camera ?: throw RtmpException("chưa có camera — gọi prepare() trước")
+      if (!active.setExposureLocked(locked)) throw RtmpException("thiết bị không hỗ trợ khoá sáng")
+    }
+
+    AsyncFunction("setTorch") Coroutine { enabled: Boolean ->
+      torchEnabled = enabled
+      camera?.setTorch(enabled)
+      Unit
+    }
+
+    // Chống chớp đèn. Khác các control trên: KHÔNG ném khi chưa có camera —
+    // config đẩy xuống lúc app khởi động (trước cả prepare), giá trị được LƯU
+    // và applyStoredControls tự áp ở mỗi lần attachCamera. HAL thiếu mode thì
+    // setAntibanding trả false và bỏ qua — đường config tự động, không phải
+    // thao tác tay cần báo lỗi.
+    AsyncFunction("setAntiFlicker") Coroutine { mode: String ->
+      val value = when (mode) {
+        "50hz" -> CameraMetadata.CONTROL_AE_ANTIBANDING_MODE_50HZ
+        "60hz" -> CameraMetadata.CONTROL_AE_ANTIBANDING_MODE_60HZ
+        else -> CameraMetadata.CONTROL_AE_ANTIBANDING_MODE_AUTO
+      }
+      antibandingMode = value
+      camera?.setAntibanding(value)
+      Unit
+    }
+
+    // ===== Overlay =====
+    // Trả BÁO CÁO như iOS — "áp im lặng" đã bị cấm sau sự cố 26/08.
+
+    AsyncFunction("setOverlayLogo") Coroutine { options: OverlayLogoOptions? ->
+      overlayLogoSpec = options
+      applyOverlay()
+    }
+
+    AsyncFunction("setOverlayAnimated") Coroutine { items: List<OverlayAnimatedOptions>? ->
+      overlayAnimatedSpecs = items ?: emptyList()
+      applyOverlay()
+    }
+
+    AsyncFunction("setOverlayTexts") Coroutine { items: List<OverlayTextOptions>? ->
+      overlayTextSpecs = items ?: emptyList()
+      applyOverlayTexts()
+    }
+
     Function("getStats") {
       mapOf(
-        "isConnected" to (session?.isConnected ?: false),
+        "isConnected" to (rtmp?.isStreaming ?: false),
         "isPublishing" to publishing,
         "videoBitrate" to videoBitrate,
-        "currentFps" to 0,
+        "currentFps" to currentFps,
       )
     }
 
+    AsyncFunction("getDeviceHealth") Coroutine { -> deviceHealth() }
+
+    // Hộp đen: vì sao tiến trình chết lần trước (Android 11+). Xem processExitReasons().
+    AsyncFunction("getProcessExitReasons") Coroutine { max: Int -> processExitReasons(max) }
+
+    // Chụp 1 ảnh JPEG base64 từ khung preview — dashboard xem trước từ xa.
+    AsyncFunction("snapshot") Coroutine { ->
+      snapshot()
+    }
+
     AsyncFunction("dispose") Coroutine { ->
       teardown()
     }
 
     OnDestroy {
-      // OnDestroy không phải coroutine — chỉ dọn phần đồng bộ được.
-      mixer?.stopRunning()
-      PickleballRtmpPreviewRegistry.setMixer(null)
-      mixer = null
-      session = null
+      stopBandwidthMonitor()
+      // Module chết mà service còn sống là thông báo treo vĩnh viễn không ai gỡ
+      // được — dispose() không phải lúc nào cũng được gọi trước khi tắt.
+      runCatching { PickleballRtmpService.stop(context) }
+      runCatching { rtmp?.disconnect() }
+      camera?.close()
+      camera = null
+      runCatching { compositor?.release() }
+      compositor = null
+      video.release()
+      audio.release()
+      copyThread?.quitSafely()
+      copyThread = null
+      PickleballRtmpPreviewRegistry.observe(null)
     }
   }
 
   // MARK: - Vòng đời
 
   private suspend fun prepare(options: PrepareOptions) {
-    val active = mixer ?: MediaMixer(context).also { mixer = it }
-    PickleballRtmpPreviewRegistry.setMixer(active)
-
     if (options.quality == 720) {
-      videoLongEdge = 1280
-      videoShortEdge = 720
+      captureWidth = 1280
+      captureHeight = 720
     } else {
-      videoLongEdge = 1920
-      videoShortEdge = 1080
+      captureWidth = 1920
+      captureHeight = 1080
     }
-    landscape = options.landscape
+    frameRate = options.frameRate
+    // Camera mặc định từ cấu hình — chỉ nhận id máy thật sự có, tránh kẹt màn
+    // đen khi cấu hình cũ trỏ vào camera không còn tồn tại.
+    options.cameraId
+      ?.takeIf { id -> availableCameras().any { it.id == id } }
+      ?.let { cameraId = it }
+
+    // Cỡ capture phải là cỡ camera THẬT hỗ trợ, nếu không HAL tự scale.
+    val (width, height) = CameraSession(context).pickSize(cameraId, captureWidth, captureHeight)
+    captureWidth = width
+    captureHeight = height
+    PickleballRtmpPreviewRegistry.setBufferSize(width, height)
 
-    // PHẢI đặt TRƯỚC startRunning(): Camera2Source.open() đọc `mixer.screen.frame`
-    // qua getCameraSize() để chọn kích thước capture. Đặt sau là camera đã chốt
-    // kích thước theo frame mặc định rồi, sửa frame lúc đó không còn tác dụng.
-    applyScreenGeometry()
     attachCamera(cameraId)
-    if (microphoneEnabled) {
-      active.attachAudio(0, AudioRecordSource(context))
-    }
-    active.startRunning()
+    // Bật foreground service NGAY tại đây, không sớm hơn không muộn hơn: từ
+    // Android 12 chỉ được khởi động FGS khi app còn tiền cảnh, mà prepare() là
+    // lúc người dùng vừa mở màn camera nên chắc chắn thoả. Camera đã mở xong
+    // rồi mới bật để không giữ thông báo khi mở camera thất bại.
+    PickleballRtmpService.start(context)
     emitStatus(mapOf("status" to "idle"))
   }
 
-  /** Kích thước khung thật theo hướng người dùng chọn (9:16 dọc hay 16:9 ngang). */
-  private fun orientedSize(): Pair<Int, Int> =
-    if (landscape) videoLongEdge to videoShortEdge else videoShortEdge to videoLongEdge
-
   /**
-   * Đặt khung ảnh theo hướng người dùng chọn.
+   * Mở camera với encoder surface, kèm preview surface NẾU đã có.
    *
-   * `Screen.create()` đặt frame cứng ở kích thước ngang mặc định, không hề biết
-   * người dùng chọn 9:16 — không set lại là khung dọc bị bóp/cắt và
-   * Camera2Source cũng chọn sai kích thước capture.
-   *
-   * LiveKit không cần bước này vì WebRTC gắn metadata xoay vào TỪNG FRAME rồi
-   * để phía phát xoay; HaishinKit nướng thẳng hướng vào ảnh đã mã hoá.
-   *
-   * Ghi chú: `VideoScreenObject.isRotatesWithContent` (cờ quyết định có cộng
-   * `deviceOrientation` vào góc xoay hay không) KHÔNG chạm tới được từ ngoài —
-   * `findByClass` là `internal` và `id` của object là UUID ngẫu nhiên nên
-   * `findById` cũng vô dụng. Nếu chỉ set frame mà hình vẫn lệch thì phải tự
-   * thêm một VideoScreenObject của mình vào screen.
+   * KHÔNG được chờ preview: app chỉ mount PickleballRtmpPreviewView khi
+   * `previewTrack` khác null, mà previewTrack chỉ có SAU khi prepare() xong —
+   * chờ ở đây là bế tắc vòng tròn (đã dính đúng lỗi này). Nên mở trước với
+   * encoder, rồi dựng lại session khi surface preview xuất hiện.
    */
-  private fun applyScreenGeometry() {
-    val active = mixer ?: return
-    val (width, height) = orientedSize()
-    active.screen.frame = Rect(0, 0, width, height)
+  private suspend fun attachCamera(id: String) {
+    val preview = PickleballRtmpPreviewRegistry.current()
+    attachedPreview = preview
+
+    camera?.close()
+    camera = null
+    // Encoder phải sẵn sàng TRƯỚC khi mở camera: input surface là một trong hai
+    // target của capture session.
+    video.release()
+    video.prepare(captureWidth, captureHeight, frameRate, videoBitrate)
+    val encoderSurface = video.inputSurface
+      ?: throw RtmpException("không tạo được input surface cho encoder")
+    video.start(
+      onHeader = { s, p ->
+        // Giữ bản sao: buffer của MediaCodec bị tái sử dụng sau khi release.
+        sps = cloneBuffer(s)
+        pps = p?.let { cloneBuffer(it) }
+      },
+      onFrame = { buffer, info ->
+        if (publishing) {
+          if (videoPtsBaseUs < 0) videoPtsBaseUs = info.presentationTimeUs
+          info.presentationTimeUs -= videoPtsBaseUs
+          rtmp?.sendVideo(buffer, info)
+        }
+      },
+    )
+
+    // Có overlay → chen pass GL giữa camera và encoder (preview cũng nhận bản
+    // đã compose để PixelCopy/dashboard thấy đúng cái đang lên sóng — khớp iOS).
+    // Không overlay → giữ NGUYÊN đường addTarget thẳng, zero GL như kiến trúc
+    // 08/08. GL dựng hỏng thì rơi về đường thẳng: mất overlay chứ không mất sóng.
+    compositor?.release()
+    compositor = null
+    val targets: List<Surface>
+    if (hasOverlay) {
+      val gl = runCatching {
+        GlCompositor(
+          context, captureWidth, captureHeight, encoderSurface,
+          cameraRotation = cameraRotationFor(id),
+        )
+      }.getOrNull()
+      if (gl?.inputSurface != null) {
+        gl.setLayers(buildLayerSpecs())
+        gl.setTextLayers(buildTextSpecs())
+        preview?.let { gl.setPreviewSurface(it, captureWidth, captureHeight) }
+        compositor = gl
+        targets = listOfNotNull(gl.inputSurface)
+      } else {
+        gl?.release()
+        targets = listOfNotNull(preview, encoderSurface)
+      }
+    } else {
+      targets = listOfNotNull(preview, encoderSurface)
+    }
+
+    val session = CameraSession(context)
+    session.open(id, targets, frameRate)
+    camera = session
+    cameraId = id
+    applyStoredControls()
+    observePreviewSurface()
   }
 
-  private suspend fun connect(options: ConnectOptions) {
-    val active = mixer ?: throw RtmpException("gọi prepare() trước khi connect()")
+  /**
+   * Áp trạng thái overlay. Có/không overlay quyết định KIẾN TRÚC pipeline
+   * (GL pass vs addTarget thẳng) nên CHUYỂN trạng thái là dựng lại camera —
+   * hiếm (BTC lưu giữa trận), chấp nhận khựng ~0.3s như một lần đổi lens.
+   * Cùng trạng thái thì chỉ thay danh sách lớp trên compositor đang chạy.
+   */
+  private suspend fun applyOverlay(): Map<String, Any> {
+    if (camera?.isOpen != true) {
+      // Chưa prepare — spec đã lưu, attachCamera lần tới tự mang theo.
+      return mapOf("applied" to false, "why" to "no_camera")
+    }
+    val active = compositor
+    if (hasOverlay == (active != null)) {
+      return if (active != null) {
+        active.setLayers(buildLayerSpecs())
+        mapOf("applied" to true, "mode" to "gl", "items" to active.lastLayerReport)
+      } else {
+        mapOf("applied" to true, "mode" to "direct", "count" to 0)
+      }
+    }
+    attachCamera(cameraId)
+    val rebuilt = compositor
+    if (hasOverlay && rebuilt == null) {
+      return mapOf("applied" to false, "why" to "gl_setup_failed", "mode" to "direct")
+    }
+    return mapOf(
+      "applied" to true,
+      "mode" to if (rebuilt != null) "gl" else "direct",
+      "items" to (rebuilt?.lastLayerReport ?: emptyList<Map<String, Any>>()),
+    )
+  }
 
-    // Cùng cái bẫy như iOS: registry factory khởi tạo RỖNG, thiếu bước này thì
-    // build() không nhận ra scheme rtmp:// dù URL hoàn toàn hợp lệ.
-    StreamSession.Builder.registerFactory(RtmpStreamSessionFactory)
+  /**
+   * Áp RIÊNG lớp chữ. Khác applyOverlay ở một điểm sống còn: cùng-trạng-thái
+   * thì CHỈ gọi setTextLayers — tuyệt đối không setLayers lại media (rebuild là
+   * restart MediaPlayer của lớp video giữa sóng). Chuyển trạng thái pipeline
+   * (0 overlay ↔ có) vẫn phải dựng lại camera như applyOverlay.
+   */
+  private suspend fun applyOverlayTexts(): Map<String, Any> {
+    if (camera?.isOpen != true) {
+      return mapOf("applied" to false, "why" to "no_camera")
+    }
+    val active = compositor
+    if (hasOverlay == (active != null)) {
+      return if (active != null) {
+        active.setTextLayers(buildTextSpecs())
+        mapOf("applied" to true, "mode" to "gl", "items" to active.lastTextReport)
+      } else {
+        mapOf("applied" to true, "mode" to "direct", "count" to 0)
+      }
+    }
+    attachCamera(cameraId)
+    val rebuilt = compositor
+    if (hasOverlay && rebuilt == null) {
+      return mapOf("applied" to false, "why" to "gl_setup_failed", "mode" to "direct")
+    }
+    return mapOf(
+      "applied" to true,
+      "mode" to if (rebuilt != null) "gl" else "direct",
+      "items" to (rebuilt?.lastTextReport ?: emptyList<Map<String, Any>>()),
+    )
+  }
 
-    emitStatus(mapOf("status" to "connecting"))
-    try {
-      val built = StreamSession.Builder(context, Uri.parse(options.url))
-        .setMode(StreamSession.Mode.PUBLISH)
-        .build()
-      session = built
-      active.registerOutput(built.stream)
+  /** #rrggbb → ARGB; alpha nhân riêng (nền). Sai định dạng → fallback. */
+  private fun argbOf(hex: String?, alpha: Double, fallback: Int): Int {
+    val h = hex?.trim()?.removePrefix("#") ?: return fallback
+    val rgb = h.toIntOrNull(16) ?: return fallback
+    if (h.length != 6) return fallback
+    val a = (alpha.coerceIn(0.0, 1.0) * 255).toInt()
+    return (a shl 24) or rgb
+  }
 
-      videoBitrate = options.videoBitrate
-      applyVideoBitrate(options.videoBitrate)
-      options.audioBitrate?.let { built.stream.audioSetting.bitRate = it }
+  private fun buildTextSpecs(): List<GlCompositor.TextSpec> =
+    overlayTextSpecs.map {
+      GlCompositor.TextSpec(
+        id = it.id,
+        text = it.text,
+        x = it.x.toInt(),
+        y = it.y.toInt(),
+        fontSizePx = it.fontSizePx.toInt(),
+        align = it.align,
+        bold = it.weight != "regular",
+        colorArgb = argbOf(it.color, 1.0, 0xffffffff.toInt()),
+        opacity = it.opacity.toFloat().coerceIn(0f, 1f),
+        bgArgb = it.bgColor?.let { bg -> argbOf(bg, it.bgOpacity ?: 0.5, 0x8c000000.toInt()) },
+      )
+    }
 
-      emitStatus(mapOf("status" to "connected"))
-      if (options.publish) setPublishing(true)
-    } catch (error: Throwable) {
-      session = null
-      emitStatus(
-        mapOf(
-          "status" to "error",
-          "code" to "connect_failed",
-          "message" to (error.message ?: error.toString()),
+  private fun buildLayerSpecs(): List<GlCompositor.LayerSpec> {
+    val out = mutableListOf<GlCompositor.LayerSpec>()
+    overlayLogoSpec?.let {
+      out.add(
+        GlCompositor.LayerSpec(
+          id = "__logo",
+          kind = "image",
+          filePath = it.filePath,
+          x = it.x.toInt(),
+          y = it.y.toInt(),
+          width = it.width.toInt(),
+          height = it.height.toInt(),
+          opacity = it.opacity.toFloat(),
         ),
       )
-      throw error
     }
+    overlayAnimatedSpecs.forEach {
+      out.add(
+        GlCompositor.LayerSpec(
+          id = it.id,
+          kind = it.kind,
+          filePath = it.filePath,
+          x = it.x.toInt(),
+          y = it.y.toInt(),
+          width = it.width.toInt(),
+          height = it.height.toInt(),
+          opacity = it.opacity.toFloat(),
+        ),
+      )
+    }
+    return out
+  }
+
+  /**
+   * Surface preview đến/đi sau khi camera đã mở thì phải dựng lại capture
+   * session: Camera2 chốt danh sách target ngay lúc tạo session, không thêm bớt
+   * được. Chỉ dựng lại khi surface THỰC SỰ đổi, nếu không sẽ lặp vô hạn.
+   */
+  private fun observePreviewSurface() {
+    PickleballRtmpPreviewRegistry.observe { surface ->
+      if (surface === attachedPreview) return@observe
+      // Có compositor thì preview chỉ là một EGLSurface đích — thay tại chỗ,
+      // KHÔNG dựng lại camera (camera đang ghi vào SurfaceTexture của GL).
+      compositor?.let {
+        attachedPreview = surface
+        it.setPreviewSurface(surface, captureWidth, captureHeight)
+        return@observe
+      }
+      reattachScope.launch {
+        runCatching { attachCamera(cameraId) }
+          .onFailure {
+            emitStatus(
+              mapOf(
+                "status" to "error",
+                "code" to "camera_reattach_failed",
+                "message" to (it.message ?: it.toString()),
+              ),
+            )
+          }
+      }
+    }
+  }
+
+  private fun applyStoredControls() {
+    val active = camera ?: return
+    zoomRatio?.let { active.setZoom(it) }
+    exposureBiasEv?.let { active.setExposureBias(it) }
+    if (focusLocked) active.setFocusLocked(true)
+    if (exposureLocked) active.setExposureLocked(true)
+    if (torchEnabled) active.setTorch(true)
+    antibandingMode?.let { active.setAntibanding(it) }
+  }
+
+  // MARK: - RTMP
+
+  private fun connect(options: ConnectOptions) {
+    rtmpUrl = options.url
+    videoBitrate = options.videoBitrate
+    options.audioBitrate?.let { audioBitrate = it }
+    video.setBitrate(options.videoBitrate)
+
+    // Đóng client cũ TRƯỚC khi tạo cái mới. Gán `rtmp = RtmpClient(...)` bên dưới
+    // chỉ thay tham chiếu — client cũ vẫn giữ socket RTMP đang mở, không ai đóng.
+    // engine.ts gọi connect() ở cả start() lẫn reconnect(), nên mỗi vòng reconnect
+    // rò một socket. Trên iOS lỗi y hệt đã làm MediaMTX nhận 3 kết nối cho một
+    // lần publish và giết luôn socket đang sống khi dọn hai cái mồ côi
+    // (prod 16/08/2026, phiên chết sau 24 giây).
+    rtmp?.let { stale ->
+      publishing = false
+      stopBandwidthMonitor()
+      runCatching { stale.disconnect() }
+    }
+    rtmp = null
+    videoPtsBaseUs = -1
+    audioPtsBaseUs = -1
+
+    emitStatus(mapOf("status" to "connecting"))
+    // RtmpClient chỉ mở socket ở connect(); ta giữ nguyên ngữ nghĩa cũ —
+    // "connected" = đã sẵn sàng (standby), "publishing" = thật sự đang đẩy.
+    rtmp = RtmpClient(
+      object : ConnectChecker {
+        override fun onConnectionStarted(url: String) = Unit
+
+        override fun onConnectionSuccess() {
+          publishing = true
+          startBandwidthMonitor()
+          emitStatus(mapOf("status" to "publishing"))
+        }
+
+        override fun onConnectionFailed(reason: String) {
+          // RootEncoder dùng CHUNG callback này cho hai chuyện khác hẳn nhau: bắt
+          // tay ban đầu thất bại, và socket chết GIỮA lúc đang đẩy (RtmpSender bắn
+          // "send error: …Broken pipe" khi mạng rớt). Phải tách ra, vì "error" và
+          // "disconnected" đi hai đường hoàn toàn khác ở engine — mất kết nối giữa
+          // luồng là chuyện hồi phục được, còn báo "error" thì trước đây engine chỉ
+          // ghi lỗi rồi để phiên chết vĩnh viễn (18/08/2026: Android không phát lại
+          // được sau khi mất mạng 1-2 giây, iOS hồi được vì HaishinKit báo đúng là
+          // disconnected).
+          val wasPublishing = publishing
+          publishing = false
+          stopBandwidthMonitor()
+          if (wasPublishing) {
+            emitStatus(mapOf("status" to "disconnected", "reason" to "network_loss"))
+          } else {
+            emitStatus(
+              mapOf("status" to "error", "code" to "connect_failed", "message" to reason),
+            )
+          }
+        }
+
+        override fun onDisconnect() {
+          if (publishing) {
+            publishing = false
+            stopBandwidthMonitor()
+            emitStatus(mapOf("status" to "disconnected", "reason" to "network_loss"))
+          }
+        }
+
+        override fun onAuthError() {
+          publishing = false
+          emitStatus(mapOf("status" to "error", "code" to "auth_failed", "message" to "RTMP auth"))
+        }
+
+        override fun onAuthSuccess() = Unit
+      },
+    )
+    connected = true
+    emitStatus(mapOf("status" to "connected"))
+    if (options.publish) setPublishing(true)
   }
 
-  private suspend fun setPublishing(enabled: Boolean) {
-    val active = session ?: throw RtmpException("chưa kết nối RTMP")
+  private fun setPublishing(enabled: Boolean) {
+    val client = rtmp ?: throw RtmpException("chưa kết nối RTMP")
+    val url = rtmpUrl ?: throw RtmpException("thiếu URL RTMP")
     if (enabled) {
       if (publishing) return
-      active.connect().getOrThrow()
-      publishing = true
-      emitStatus(mapOf("status" to "publishing"))
+      val header = sps ?: throw RtmpException("encoder chưa phát SPS — camera chưa có khung")
+      client.setVideoInfo(header.duplicate(), pps?.duplicate(), null)
+      if (microphoneEnabled) {
+        client.setAudioInfo(AudioEncoder.SAMPLE_RATE, AudioEncoder.IS_STEREO)
+        startAudioIfNeeded()
+      } else {
+        client.setOnlyVideo(true)
+      }
+      // Xin IDR ngay để luồng bắt đầu bằng keyframe, không chờ tới 2 giây.
+      video.requestKeyframe()
+      client.connect(url)
+      // publishing bật trong onConnectionSuccess — tránh báo "đang phát" khi
+      // socket còn chưa bắt tay xong.
     } else {
       if (!publishing) return
-      active.close()
+      stopBandwidthMonitor()
       publishing = false
+      runCatching { client.disconnect() }
+      audio.release()
       emitStatus(mapOf("status" to "connected"))
     }
   }
 
-  private suspend fun closeSession(reason: String) {
-    val active = session ?: return
-    active.close()
-    session = null
+  private fun startAudioIfNeeded() {
+    if (!microphoneEnabled) return
+    audio.release()
+    audio.prepare(audioBitrate)
+    audio.start { buffer, info ->
+      if (publishing) {
+        if (audioPtsBaseUs < 0) audioPtsBaseUs = info.presentationTimeUs
+        info.presentationTimeUs -= audioPtsBaseUs
+        rtmp?.sendAudio(buffer, info)
+      }
+    }
+  }
+
+  private fun closeSession(reason: String) {
+    stopBandwidthMonitor()
     publishing = false
+    connected = false
+    runCatching { rtmp?.disconnect() }
+    rtmp = null
+    rtmpUrl = null
+    audio.release()
     emitStatus(mapOf("status" to "disconnected", "reason" to reason))
   }
 
-  private suspend fun teardown() {
+  private fun teardown() {
     closeSession("dispose")
-    mixer?.let {
-      it.stopRunning()
-      it.attachAudio(0, null)
-      it.attachVideo(0, null)
-    }
-    PickleballRtmpPreviewRegistry.setMixer(null)
-    videoSource = null
-    mixer = null
+    camera?.close()
+    camera = null
+    compositor?.release()
+    compositor = null
+    video.release()
+    audio.release()
+    sps = null
+    pps = null
+    PickleballRtmpPreviewRegistry.observe(null)
+    // Camera đã đóng → không còn lý do giữ tiến trình ưu tiên cao, và để lại
+    // thông báo thường trực khi không quay là phiền người dùng.
+    runCatching { PickleballRtmpService.stop(context) }
   }
 
-  // MARK: - Điều chỉnh
-
   private fun applyVideoBitrate(bitsPerSecond: Int) {
-    val setting = session?.stream?.videoSetting ?: return
-    val (width, height) = orientedSize()
-    setting.bitRate = bitsPerSecond
-    // Encoder phải cùng hướng với screen, nếu không khung ra bị bóp méo.
-    setting.width = width
-    setting.height = height
-    // Keyframe 2 giây, khớp ranh giới segment HLS phía MediaMTX.
-    setting.IFrameInterval = 2
     videoBitrate = bitsPerSecond
+    // Đổi bitrate ĐỘNG, không dựng lại encoder — dựng lại là thủng segment HLS.
+    video.setBitrate(bitsPerSecond)
   }
 
-  private suspend fun attachCamera(id: String) {
-    val active = mixer ?: return
-    val source = Camera2Source(context, id)
-    active.attachVideo(0, source)
-    videoSource = source
-    cameraId = id
+  // MARK: - Băng thông
+
+  private val currentFps: Int
+    get() = lastFpsSample
+
+  private var lastFpsSample = 0
+  private var lastFrameCount = 0L
+
+  /**
+   * Bản HaishinKit cũ phải tự đo byte đẩy ra rồi so với bitrate đích. RtmpClient
+   * cho tín hiệu trực tiếp và tốt hơn: `hasCongestion()` nhìn HÀNG ĐỢI CHƯA GỬI
+   * ĐƯỢC của sender, nên nghẽn lộ ra trước khi throughput kịp tụt.
+   */
+  private fun startBandwidthMonitor() {
+    stopBandwidthMonitor()
+    bandwidthJob = bandwidthScope.launch {
+      var lastAtNanos = System.nanoTime()
+      lastFrameCount = video.encodedFrames
+      var insufficientStreak = 0
+      while (isActive) {
+        delay(BANDWIDTH_SAMPLE_MS)
+        if (!publishing) break
+        if (rtmp?.isStreaming != true) {
+          publishing = false
+          emitStatus(mapOf("status" to "disconnected", "reason" to "network_loss"))
+          break
+        }
+
+        val nowNanos = System.nanoTime()
+        val elapsedSec = (nowNanos - lastAtNanos) / 1_000_000_000.0
+        val frames = video.encodedFrames
+        if (elapsedSec > 0) {
+          lastFpsSample = ((frames - lastFrameCount) / elapsedSec).toInt()
+        }
+        lastFrameCount = frames
+        lastAtNanos = nowNanos
+
+        val congested = runCatching {
+          rtmp?.hasCongestion(CONGESTION_PERCENT) ?: false
+        }.getOrDefault(false)
+        insufficientStreak = if (congested) insufficientStreak + 1 else 0
+        sendEvent(
+          "onBandwidth",
+          mapOf(
+            // Cần 2 mẫu xấu liên tiếp mới báo nghẽn — lọc nhiễu burst ngắn.
+            "sufficient" to (insufficientStreak < 2),
+            "videoBitrate" to videoBitrate,
+          ),
+        )
+      }
+    }
   }
 
-  // MARK: - Liệt kê ống kính
+  private fun stopBandwidthMonitor() {
+    bandwidthJob?.cancel()
+    bandwidthJob = null
+  }
 
-  private data class LensInfo(val id: String, val label: String, val front: Boolean)
+  // MARK: - Snapshot
+
+  /**
+   * PixelCopy đọc thẳng từ surface preview. Bản cũ phải nhờ `screen.readPixels`
+   * của HaishinKit; giờ không còn mixer nên đọc trực tiếp, và cái đọc được đúng
+   * bằng cái đang được mã hoá vì cả hai cùng nguồn.
+   */
+  private suspend fun snapshot(): String {
+    // ĐO THẬT trên REDMI Note 15 (20/08/2026), app landscape, máy đặt ngang:
+    //   buffer=1280x720  view=1920x1080  capture=1280x720  sensor=90  display=90
+    // Công thức Camera2 lý thuyết cho (sensor - display) = 0, tức "không cần
+    // xoay" — NHƯNG so khớp ảnh chụp với màn hình máy cho thấy ngược lại: bản
+    // đã xoay -90 khớp nhất (sai khác 0.78 so với 1.18/1.20 của hai phương án
+    // kia). Kết luận: PixelCopy trả BUFFER THÔ, không mang phép xoay mà
+    // SurfaceFlinger áp lúc compose lên màn hình. Nên phải tự xoay ở đây, và
+    // đừng tin công thức display-rotation cho đường chụp này.
+    val view = PickleballRtmpPreviewRegistry.view()
+      ?: throw RtmpException("chưa có preview — gọi prepare() trước")
+    val handler = copyThread?.let { Handler(it.looper) } ?: run {
+      val thread = HandlerThread("pickleball-pixelcopy").also { it.start() }
+      copyThread = thread
+      Handler(thread.looper)
+    }
+    // Kích thước lấy từ BUFFER, không lấy theo view: PixelCopy SCALE nội dung
+    // surface vào bitmap đích, nên cấp theo view (kích thước hiển thị) là để
+    // tỉ lệ hiển thị quyết định tỉ lệ ảnh — sai ngay từ gốc.
+    val (bufferW, bufferH) = PickleballRtmpPreviewRegistry.bufferSize()
+    val srcW = bufferW.takeIf { it > 0 } ?: captureWidth
+    val srcH = bufferH.takeIf { it > 0 } ?: captureHeight
+    val degrees = sensorOrientationDegrees()
+    // ĐẢO CẠNH khi phải xoay 90/270.
+    //
+    // Buffer thô 1280x720 (ngang) đang CHỨA cảnh nằm nghiêng — cảnh đúng chiều
+    // vốn có khung 9:16, bị ép vào khung 16:9 nên đã méo sẵn. Chép vào bitmap
+    // ngang là giữ nguyên cái méo đó, xoay xong vẫn méo (đo 20/08/2026: túi
+    // chiếm 49% bề ngang ảnh so với 40% trên màn hình máy). Cấp bitmap đảo
+    // cạnh thì PixelCopy duỗi ngược lại, xoay xong ra đúng khung 16:9.
+    val swap = degrees == 90 || degrees == 270
+    val width = if (swap) srcH else srcW
+    val height = if (swap) srcW else srcH
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    val ok = withTimeoutOrNull(2_000) {
+      suspendCancellableCoroutine<Boolean> { cont ->
+        runCatching {
+          PixelCopy.request(view, bitmap, { result ->
+            if (cont.isActive) cont.resume(result == PixelCopy.SUCCESS)
+          }, handler)
+        }.onFailure { if (cont.isActive) cont.resume(false) }
+      }
+    } ?: false
+    if (!ok) {
+      bitmap.recycle()
+      throw RtmpException("không lấy được khung hình (PixelCopy thất bại)")
+    }
+    // Xoay NGƯỢC hướng cảm biến. Camera2 ghi thẳng vào surface theo hướng cảm
+    // biến; phép xoay chỉ được SurfaceFlinger áp lúc HIỂN THỊ, nên màn hình máy
+    // nhìn đúng còn bản chép ra thì lệch — đây là lý do chỉ Android dính, iOS
+    // lấy pixel buffer đã đúng chiều.
+    //
+    // 🔴 Ghi chú cũ ở đây từng kết luận "xoay theo SENSOR_ORIENTATION cho kết
+    // quả TỆ HƠN, đừng thử lại". Sai ở DẤU chứ không ở ý tưởng: xoay +90 khi
+    // cảm biến lệch 90 làm ảnh thành lệch 180 — trông còn tệ hơn ảnh gốc, nên
+    // bị hiểu nhầm là hướng sai. Đo trên máy thật 20/08/2026 (REDMI Note 15):
+    // ảnh lệch THEO chiều kim đồng hồ → phải xoay NGƯỢC lại đúng chừng đó.
+    if (degrees == 0) return encodeJpegBase64(bitmap, 480, 50)
+    val matrix = Matrix().apply { postRotate(-degrees.toFloat()) }
+    val rotated = runCatching {
+      Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+    }.getOrNull()
+    if (rotated == null || rotated === bitmap) return encodeJpegBase64(bitmap, 480, 50)
+    bitmap.recycle()
+    return encodeJpegBase64(rotated, 480, 50)
+  }
+
+  /**
+   * Xoay nguồn cho GL compositor — chuẩn tham chiếu là camera SAU (sensor 90,
+   * buffer tự nhiên đúng chiều như đường addTarget thẳng đã kiểm field). Camera
+   * khác sensor thì bù phần lệch so với 90 (front 270 → 180).
+   */
+  private fun cameraRotationFor(id: String): Int {
+    val sensor = runCatching {
+      (context.getSystemService(Context.CAMERA_SERVICE) as CameraManager)
+        .getCameraCharacteristics(id)
+        .get(CameraCharacteristics.SENSOR_ORIENTATION)
+    }.getOrNull() ?: 90
+    return (((sensor - 90) % 360) + 360) % 360
+  }
+
+  /**
+   * Độ lệch của cảm biến so với ảnh cần hiển thị (0/90/180/270). Đọc từ
+   * CameraCharacteristics thay vì hằng số cứng: máy trước/sau và từng đời máy
+   * khác nhau, hằng số 90 đúng với REDMI nhưng không đúng với mọi máy.
+   */
+  private fun sensorOrientationDegrees(): Int {
+    val value = camera?.characteristics()?.get(CameraCharacteristics.SENSOR_ORIENTATION) ?: 0
+    // Chuẩn hoá về [0,360) rồi ép về bội số 90 — giá trị lạ thì coi như không xoay.
+    return when (((value % 360) + 360) % 360) {
+      90 -> 90
+      180 -> 180
+      270 -> 270
+      else -> 0
+    }
+  }
+
+  private fun encodeJpegBase64(bitmap: Bitmap, maxWidth: Int, quality: Int): String {
+    try {
+      val scaled = if (bitmap.width > maxWidth) {
+        val height = (bitmap.height.toFloat() * maxWidth / bitmap.width).toInt().coerceAtLeast(1)
+        Bitmap.createScaledBitmap(bitmap, maxWidth, height, true)
+      } else {
+        bitmap
+      }
+      val stream = ByteArrayOutputStream()
+      scaled.compress(Bitmap.CompressFormat.JPEG, quality, stream)
+      if (scaled !== bitmap) scaled.recycle()
+      return Base64.encodeToString(stream.toByteArray(), Base64.NO_WRAP)
+    } finally {
+      bitmap.recycle()
+    }
+  }
+
+  // MARK: - Sức khoẻ máy (nhiệt + pin)
+
+  /**
+   * Mức tiết giảm nhiệt và nhiệt độ pin — hai thứ quyết định máy có trụ nổi cả
+   * ngày giải hay không.
+   *
+   * 🔴 Vì sao phải là native: không package Expo nào đọc được hai giá trị này.
+   * Hai ngày thực địa 08–09/08/2026 ghi 5.598 mẫu `deviceMetrics` mà `thermal`
+   * và `batteryTempC` RỖNG TRẮNG cả hai — nên khi máy tụt pin còn 10% và nghi
+   * quá nhiệt thì không có một số liệu nào để đối chiếu.
+   *
+   * Cả hai đều optional: máy cũ (API < 29) không có thermal, nhánh pin thiếu
+   * intent thì bỏ trường đó. Đọc hỏng KHÔNG được phép ném lỗi — collector chạy
+   * trong nhịp heartbeat, làm gãy nó là mất luôn mọi chỉ số khác.
+   */
+  private fun deviceHealth(): Map<String, Any> {
+    val out = mutableMapOf<String, Any>()
+
+    // THERMAL_STATUS_*: 0 NONE · 1 LIGHT · 2 MODERATE · 3 SEVERE · 4 CRITICAL
+    // · 5 EMERGENCY · 6 SHUTDOWN. Dashboard báo "máy quá nóng" từ mức 3.
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      runCatching {
+        val power = context.getSystemService(Context.POWER_SERVICE) as? PowerManager
+        power?.currentThermalStatus
+      }.getOrNull()?.let { out["thermal"] = it }
+    }
+
+    // Sticky broadcast: truyền null receiver = đọc giá trị hiện tại rồi thôi,
+    // không đăng ký lắng nghe (không có gì phải nhớ gỡ).
+    runCatching {
+      val intent = context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
+      // EXTRA_TEMPERATURE tính bằng 1/10 °C; -1 = máy không báo.
+      val tenths = intent?.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, -1) ?: -1
+      if (tenths > 0) out["batteryTempC"] = tenths / 10.0
+    }
+
+    return out
+  }
 
   /**
-   * Android không có `localizedName` như AVFoundation, nên nhãn phải TỰ DỰNG
-   * đúng dạng tiếng Anh mà UI dò (`/ultra\s*wide/i`, `/telephoto/i` trong
-   * livestream-screen). Trả nhãn dạng khác thì cả ba ống kính đều hiện "1x" —
-   * đúng lỗi đã gặp trên iOS.
+   * Lý do các lần tiến trình chết gần đây, mới nhất trước — đọc từ
+   * ActivityManager.getHistoricalProcessExitReasons (Android 11+, hệ thống giữ
+   * vài ngày). Đây là cách DUY NHẤT biết máy gác sân chết vì gì mà không cắm
+   * cáp: 22/08/2026 camera sân 4 im 21 phút giữa giải, phải cắm adb mới thấy
+   * `reason=PACKAGE_UPDATED · stop com.google.android.webview` (Play Store tự
+   * cập nhật WebView, Android giết mọi app đang load WebView — app RN nào cũng
+   * dính qua CookieManager). App gửi danh sách này lên heartbeat, dashboard hiện.
    *
-   * Phân loại theo tiêu cự so với ống chính: ngắn hơn = siêu rộng, dài hơn = tele.
+   * Mã reason theo ApplicationExitInfo.REASON_* — đổi sang tên ở đây để JS và
+   * dashboard không phải giữ bảng mã riêng. Máy < API 30 trả rỗng, không ném.
    */
+  private fun processExitReasons(max: Int): List<Map<String, Any>> {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) return emptyList()
+    val limit = max.coerceIn(1, 16)
+    return runCatching {
+      val manager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+      manager.getHistoricalProcessExitReasons(context.packageName, 0, limit).map { info ->
+        val out = mutableMapOf<String, Any>(
+          "at" to info.timestamp,
+          "pid" to info.pid,
+          "reason" to info.reason,
+          "reasonName" to exitReasonName(info.reason),
+          "importance" to info.importance,
+          "status" to info.status,
+        )
+        info.description?.let { out["description"] = it }
+        out
+      }
+    }.getOrDefault(emptyList())
+  }
+
+  private fun exitReasonName(reason: Int): String = when (reason) {
+    ApplicationExitInfo.REASON_EXIT_SELF -> "EXIT_SELF"
+    ApplicationExitInfo.REASON_SIGNALED -> "SIGNALED"
+    ApplicationExitInfo.REASON_LOW_MEMORY -> "LOW_MEMORY"
+    ApplicationExitInfo.REASON_CRASH -> "CRASH"
+    ApplicationExitInfo.REASON_CRASH_NATIVE -> "CRASH_NATIVE"
+    ApplicationExitInfo.REASON_ANR -> "ANR"
+    ApplicationExitInfo.REASON_INITIALIZATION_FAILURE -> "INITIALIZATION_FAILURE"
+    ApplicationExitInfo.REASON_PERMISSION_CHANGE -> "PERMISSION_CHANGE"
+    ApplicationExitInfo.REASON_EXCESSIVE_RESOURCE_USAGE -> "EXCESSIVE_RESOURCE_USAGE"
+    ApplicationExitInfo.REASON_USER_REQUESTED -> "USER_REQUESTED"
+    ApplicationExitInfo.REASON_USER_STOPPED -> "USER_STOPPED"
+    ApplicationExitInfo.REASON_DEPENDENCY_DIED -> "DEPENDENCY_DIED"
+    ApplicationExitInfo.REASON_OTHER -> "OTHER"
+    ApplicationExitInfo.REASON_FREEZER -> "FREEZER"
+    ApplicationExitInfo.REASON_PACKAGE_STATE_CHANGE -> "PACKAGE_STATE_CHANGE"
+    ApplicationExitInfo.REASON_PACKAGE_UPDATED -> "PACKAGE_UPDATED"
+    else -> "UNKNOWN"
+  }
+
+  // MARK: - Camera list
+
+  private data class LensInfo(val id: String, val label: String, val front: Boolean)
+
+  private fun isFront(id: String) = availableCameras().firstOrNull { it.id == id }?.front == true
+
+  private fun frontCameraId() = availableCameras().firstOrNull { it.front }?.id
+
   private fun availableCameras(): List<LensInfo> {
     val manager = context.getSystemService(Context.CAMERA_SERVICE) as? CameraManager
       ?: return emptyList()
@@ -305,16 +1025,66 @@ class PickleballRtmpNativeModule : Module() {
     } + front.map { LensInfo(it.first, "Front Camera", true) }
   }
 
-  private fun isFront(id: String) = availableCameras().firstOrNull { it.id == id }?.front == true
+  /** Bounds cho UI — sheet điều khiển ẨN control nào supported:false. */
+  private fun cameraCapabilities(): Map<String, Any> {
+    val chars = camera?.characteristics() ?: runCatching {
+      (context.getSystemService(Context.CAMERA_SERVICE) as CameraManager)
+        .getCameraCharacteristics(cameraId)
+    }.getOrNull()
+    val open = camera?.isOpen == true
 
-  private fun frontCameraId() = availableCameras().firstOrNull { it.front }?.id
+    val zoomRange = chars?.get(CameraCharacteristics.CONTROL_ZOOM_RATIO_RANGE)
+    val maxDigital = chars?.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM) ?: 1f
+    val evRange = chars?.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE)
+    val evStep = chars?.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_STEP)?.toFloat() ?: 0f
+    val afModes = chars?.get(CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES)
+    val hasFlash = chars?.get(CameraCharacteristics.FLASH_INFO_AVAILABLE) ?: false
+
+    // Lọc theo đúng tiêu chí setFpsRange() dùng lúc chạy: phải có AE range phủ
+    // được fps đó, nếu không camera sẽ chạy một tốc độ khác với encoder.
+    val aeRanges = chars?.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES)
+    val frameRates = OFFERED_FRAME_RATES.filter { fps ->
+      aeRanges?.any { fps >= it.lower && fps <= it.upper } == true
+    }.ifEmpty { listOf(30) }
+
+    return mapOf(
+      "supportedFrameRates" to frameRates,
+      "zoom" to mapOf(
+        "supported" to open,
+        "min" to (zoomRange?.lower?.toDouble() ?: 1.0),
+        "max" to (zoomRange?.upper?.toDouble() ?: maxDigital.toDouble()),
+      ),
+      "exposureBias" to mapOf(
+        "supported" to (open && evRange != null && evStep > 0f),
+        "min" to ((evRange?.lower ?: 0) * evStep).toDouble(),
+        "max" to ((evRange?.upper ?: 0) * evStep).toDouble(),
+      ),
+      "focusLock" to mapOf(
+        "supported" to (open && afModes?.contains(1) == true),
+      ),
+      "exposureLock" to mapOf("supported" to open),
+      "torch" to mapOf("supported" to (open && hasFlash)),
+    )
+  }
+
+  private fun cloneBuffer(source: ByteBuffer): ByteBuffer {
+    val copy = ByteBuffer.allocateDirect(source.remaining())
+    copy.put(source.duplicate())
+    copy.flip()
+    return copy
+  }
 
   private fun emitStatus(payload: Map<String, Any?>) {
-    sendEvent("onStatusChanged", payload)
+    runCatching { sendEvent("onStatusChanged", payload) }
   }
 
   private companion object {
     const val BACK_DEFAULT_ID = "0"
+    const val BANDWIDTH_SAMPLE_MS = 2_000L
+    /** Hàng đợi sender dùng quá % này thì coi là nghẽn (mặc định lib là 20). */
+    const val CONGESTION_PERCENT = 20f
+    /** fps mà UI được phép chào — phải khớp `offeredFrameRates` bên iOS. */
+    val OFFERED_FRAME_RATES = listOf(24, 30, 60)
   }
 }
 
@@ -323,8 +1093,14 @@ class PrepareOptions : Record {
 
   @Field val frameRate: Int = 30
 
-  /** Khung người dùng chọn: true = 16:9 ngang, false = 9:16 dọc. */
+  /**
+   * Giữ lại cho tương thích API, nhưng Android SAU khi bỏ tầng GL chỉ phát
+   * khung ngang — xoay sang 9:16 cần đúng bước xoay ảnh vừa được loại bỏ.
+   */
   @Field val landscape: Boolean = true
+
+  /** Camera mặc định người dùng chọn; null = giữ BACK_DEFAULT_ID. */
+  @Field val cameraId: String? = null
 }
 
 class ConnectOptions : Record {
@@ -334,7 +1110,71 @@ class ConnectOptions : Record {
 
   @Field val audioBitrate: Int? = null
 
+  /** false = chuẩn bị sẵn nhưng chưa phát (standby). */
   @Field val publish: Boolean = true
 }
 
+/** Ô đặt overlay tĩnh — PIXEL của khung encode, gốc trên-trái (JS tính bằng shared). */
+class OverlayLogoOptions : Record {
+  @Field val filePath: String = ""
+
+  @Field val x: Double = 0.0
+
+  @Field val y: Double = 0.0
+
+  @Field val width: Double = 0.0
+
+  @Field val height: Double = 0.0
+
+  @Field val opacity: Double = 1.0
+}
+
+/** Một lớp overlay ĐỘNG (gif/video) — cùng hệ pixel, thêm id + kind. */
+class OverlayAnimatedOptions : Record {
+  @Field val id: String = ""
+
+  @Field val kind: String = ""
+
+  @Field val filePath: String = ""
+
+  @Field val x: Double = 0.0
+
+  @Field val y: Double = 0.0
+
+  @Field val width: Double = 0.0
+
+  @Field val height: Double = 0.0
+
+  @Field val opacity: Double = 1.0
+}
+
+/**
+ * Một lớp CHỮ đã điền sẵn — JS gửi CHUỖI CHỐT + hình học pixel (mỏ neo x theo
+ * align); native chỉ vẽ. Nền là field PHẲNG (bgColor/bgOpacity) — không có
+ * bgColor = không nền.
+ */
+class OverlayTextOptions : Record {
+  @Field val id: String = ""
+
+  @Field val text: String = ""
+
+  @Field val x: Double = 0.0
+
+  @Field val y: Double = 0.0
+
+  @Field val fontSizePx: Double = 48.0
+
+  @Field val align: String = "left"
+
+  @Field val weight: String = "bold"
+
+  @Field val color: String = "#ffffff"
+
+  @Field val opacity: Double = 1.0
+
+  @Field val bgColor: String? = null
+
+  @Field val bgOpacity: Double? = null
+}
+
 class RtmpException(detail: String) : CodedException("ERR_PICKLEBALL_RTMP", detail, null)