@pickleball/rtmp-native 0.1.0 → 0.2.0

package/android/build.gradle

@@ -16,15 +16,24 @@ android {
 }
 
 repositories {
-  // HaishinKit.kt phát hành qua JitPack, không có trên Maven Central.
+  // RootEncoder phát hành qua JitPack, không có trên Maven Central.
   maven { url 'https://jitpack.io' }
 }
 
 dependencies {
   implementation 'androidx.core:core-ktx:1.15.0'
-  // Bản Kotlin của HaishinKit. API KHÁC bản Swift: MediaMixer(context),
-  // StreamSession.Builder(...).build(), mixer.registerOutput(...).
-  implementation 'com.github.HaishinKit.HaishinKit~kt:haishinkit:0.18.2'
-  // Module rtmp tách riêng — thiếu nó thì không có RtmpStreamSessionFactory.
-  implementation 'com.github.HaishinKit.HaishinKit~kt:rtmp:0.18.2'
+  // CHỈ module `rtmp` của RootEncoder — thuần giao thức đường truyền
+  // (RtmpClient: connect/setVideoInfo/sendVideo/sendAudio, nhận thẳng buffer
+  // của MediaCodec). KHÔNG dùng module `library` vì phần camera/GL của nó cũng
+  // đi qua một tầng OpenGL, mà đo thực tế cho thấy Camera2 trần hơn hẳn.
+  //
+  // Đã bỏ HaishinKit.kt: MediaMixer của nó lấy mẫu texture bằng GL_NEAREST và
+  // quên glBindTexture ở nhánh video, gây răng cưa trên cạnh chéo; vá cả hai
+  // vẫn không hết vì khuyết tật nằm ở kiến trúc render.
+  //
+  // GHIM 2.7.0, KHÔNG nâng lên 2.7.5+ hay 2.8.0: những bản đó biên dịch bằng
+  // Kotlin 2.3.x (metadata 2.3.0) trong khi compiler của Expo SDK 57 là 2.1.0,
+  // chỉ đọc được metadata tới 2.2.0 — nâng lên là hỏng toàn bộ stdlib với
+  // hàng loạt "Unresolved reference". 2.7.0 dùng Kotlin 2.2.21 → metadata 2.2.0.
+  implementation 'com.github.pedroSG94.RootEncoder:rtmp:2.7.0'
 }

package/android/src/main/AndroidManifest.xml

@@ -2,4 +2,30 @@
   <uses-permission android:name="android.permission.CAMERA" />
   <uses-permission android:name="android.permission.RECORD_AUDIO" />
   <uses-permission android:name="android.permission.INTERNET" />
+
+  <!--
+    Foreground service giữ tiến trình sống khi app ở nền (xem
+    PickleballRtmpService). Khai báo Ở ĐÂY chứ không phải ở manifest của app:
+    module là nơi sở hữu service, nên mọi app dùng module đều nhận đủ quyền qua
+    manifest merge — không ai phải nhớ chép tay.
+
+    POST_NOTIFICATIONS: Android 13+ cần quyền này để HIỆN thông báo. Thiếu quyền
+    thì service vẫn chạy đủ đặc quyền, chỉ là thông báo bị ẩn.
+  -->
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+  <application>
+    <!--
+      foregroundServiceType PHẢI khớp với cờ truyền vào startForeground(), nếu
+      không Android 14+ ném IllegalArgumentException ngay lúc gọi.
+      exported=false: không thành phần ngoài nào được phép khởi động service này.
+    -->
+    <service
+      android:name=".PickleballRtmpService"
+      android:exported="false"
+      android:foregroundServiceType="camera|microphone" />
+  </application>
 </manifest>

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

@@ -0,0 +1,252 @@
+package expo.modules.pickleballrtmp
+
+import android.content.Context
+import android.graphics.Rect
+import android.hardware.camera2.CameraCaptureSession
+import android.hardware.camera2.CameraCharacteristics
+import android.hardware.camera2.CameraDevice
+import android.hardware.camera2.CameraManager
+import android.hardware.camera2.CameraMetadata
+import android.hardware.camera2.CaptureRequest
+import android.os.Build
+import android.os.Handler
+import android.os.HandlerThread
+import android.util.Range
+import android.view.Surface
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+import kotlin.math.roundToInt
+
+/**
+ * Sở hữu trực tiếp một session Camera2 ghi ra NHIỀU surface song song.
+ *
+ * Thay cho Camera2Controls.kt cũ — file đó phải reflection vào field private của
+ * Camera2Source (HaishinKit) vì thư viện không public builder/session, và mọi
+ * lệnh set rơi im lặng khi capture session chưa kịp tạo. Ở đây ta tự giữ
+ * `CaptureRequest.Builder` nên tất cả zoom/EV/khoá nét/khoá sáng/fps/đèn chỉ là
+ * key thường, đặt xong gọi lại setRepeatingRequest — không reflection, không
+ * đoán, lỗi thì biết ngay.
+ */
+internal class CameraSession(private val context: Context) {
+  private var device: CameraDevice? = null
+  private var session: CameraCaptureSession? = null
+  private var builder: CaptureRequest.Builder? = null
+  private var thread: HandlerThread? = null
+  private var handler: Handler? = null
+  private var targets: List<Surface> = emptyList()
+
+  var cameraId: String = "0"
+    private set
+
+  private val manager: CameraManager
+    get() = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+
+  fun characteristics(): CameraCharacteristics? =
+    runCatching { manager.getCameraCharacteristics(cameraId) }.getOrNull()
+
+  /**
+   * Chọn cỡ capture khớp yêu cầu. Ưu tiên khớp CHÍNH XÁC: mọi cỡ lệch đều buộc
+   * ai đó phải scale, và scale là thứ ta vừa bỏ công loại khỏi pipeline.
+   */
+  fun pickSize(id: String, width: Int, height: Int): Pair<Int, Int> {
+    val map = runCatching {
+      manager.getCameraCharacteristics(id)
+        .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
+    }.getOrNull() ?: return width to height
+    val sizes = map.getOutputSizes(android.media.MediaCodec::class.java) ?: return width to height
+    sizes.firstOrNull { it.width == width && it.height == height }?.let {
+      return it.width to it.height
+    }
+    // Không có cỡ khớp: lấy cỡ cùng tỉ lệ, lớn hơn gần nhất.
+    val ratio = width.toDouble() / height
+    return sizes
+      .filter { it.width >= width && kotlin.math.abs(it.width.toDouble() / it.height - ratio) < 0.02 }
+      .minByOrNull { it.width.toLong() * it.height }
+      ?.let { it.width to it.height }
+      ?: (width to height)
+  }
+
+  suspend fun open(id: String, surfaces: List<Surface>, fps: Int) {
+    close()
+    cameraId = id
+    targets = surfaces
+    thread = HandlerThread("pickleball-camera").also {
+      it.start()
+      handler = Handler(it.looper)
+    }
+
+    val opened = suspendCancellableCoroutine { cont ->
+      runCatching {
+        manager.openCamera(
+          id,
+          object : CameraDevice.StateCallback() {
+            override fun onOpened(camera: CameraDevice) {
+              if (cont.isActive) cont.resume(Result.success(camera))
+            }
+
+            override fun onDisconnected(camera: CameraDevice) {
+              camera.close()
+              if (cont.isActive) {
+                cont.resume(Result.failure(RtmpException("camera $id bị ngắt")))
+              }
+            }
+
+            override fun onError(camera: CameraDevice, error: Int) {
+              camera.close()
+              if (cont.isActive) {
+                cont.resume(Result.failure(RtmpException("không mở được camera $id (mã $error)")))
+              }
+            }
+          },
+          handler,
+        )
+      }.onFailure { if (cont.isActive) cont.resume(Result.failure(it)) }
+    }.getOrThrow()
+    device = opened
+
+    @Suppress("DEPRECATION")
+    val configured = suspendCancellableCoroutine { cont ->
+      runCatching {
+        opened.createCaptureSession(
+          surfaces,
+          object : CameraCaptureSession.StateCallback() {
+            override fun onConfigured(value: CameraCaptureSession) {
+              if (cont.isActive) cont.resume(Result.success(value))
+            }
+
+            override fun onConfigureFailed(value: CameraCaptureSession) {
+              if (cont.isActive) {
+                cont.resume(Result.failure(RtmpException("không cấu hình được capture session")))
+              }
+            }
+          },
+          handler,
+        )
+      }.onFailure { if (cont.isActive) cont.resume(Result.failure(it)) }
+    }.getOrThrow()
+    session = configured
+
+    // TEMPLATE_RECORD: tuning cho video liên tục, khác TEMPLATE_PREVIEW ở chỗ
+    // ưu tiên fps ổn định hơn là độ trễ lấy nét.
+    builder = opened.createCaptureRequest(CameraDevice.TEMPLATE_RECORD).apply {
+      surfaces.forEach { addTarget(it) }
+      setFpsRange(this, fps)
+    }
+    applyRepeating()
+  }
+
+  fun close() {
+    runCatching { session?.stopRepeating() }
+    runCatching { session?.close() }
+    session = null
+    runCatching { device?.close() }
+    device = null
+    builder = null
+    thread?.quitSafely()
+    thread = null
+    handler = null
+    targets = emptyList()
+  }
+
+  val isOpen: Boolean get() = session != null && builder != null
+
+  private fun applyRepeating(): Boolean = runCatching {
+    val active = session ?: return false
+    val request = builder ?: return false
+    active.setRepeatingRequest(request.build(), null, handler)
+    true
+  }.getOrDefault(false)
+
+  // MARK: - Điều khiển (CaptureRequest key thường, không reflection)
+
+  private fun setFpsRange(target: CaptureRequest.Builder, fps: Int) {
+    val ranges = characteristics()
+      ?.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES) ?: return
+    val exact = ranges.firstOrNull { it.lower == fps && it.upper == fps }
+      ?: ranges.filter { fps in it.lower..it.upper }.minByOrNull { it.upper - it.lower }
+      ?: return
+    // Ghim LUÔN, kể cả 30: bỏ qua thì AE nằm ở range mặc định của HAL (đo trên
+    // Redmi Note 15 ra [15,30]) và thiếu sáng là tụt về 15fps, shutter dài gấp
+    // đôi, bóng nhoè — trong khi encoder vẫn chạy 30 và nhân đôi khung.
+    target.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, Range(exact.lower, exact.upper))
+  }
+
+  fun setZoom(ratio: Float): Boolean {
+    val request = builder ?: return false
+    val chars = characteristics() ?: return false
+    if (Build.VERSION.SDK_INT >= 30) {
+      val range = chars.get(CameraCharacteristics.CONTROL_ZOOM_RATIO_RANGE) ?: return false
+      request.set(CaptureRequest.CONTROL_ZOOM_RATIO, ratio.coerceIn(range.lower, range.upper))
+    } else {
+      val max = chars.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM) ?: return false
+      val active = chars.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE) ?: return false
+      val clamped = ratio.coerceIn(1f, max)
+      val cropWidth = (active.width() / clamped).toInt()
+      val cropHeight = (active.height() / clamped).toInt()
+      val left = active.left + (active.width() - cropWidth) / 2
+      val top = active.top + (active.height() - cropHeight) / 2
+      request.set(
+        CaptureRequest.SCALER_CROP_REGION,
+        Rect(left, top, left + cropWidth, top + cropHeight),
+      )
+    }
+    return applyRepeating()
+  }
+
+  fun setExposureBias(ev: Float): Boolean {
+    val request = builder ?: return false
+    val chars = characteristics() ?: return false
+    val range = chars.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE) ?: return false
+    val step = chars.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_STEP)
+      ?.toFloat()?.takeIf { it > 0f } ?: return false
+    val index = (ev / step).roundToInt().coerceIn(range.lower, range.upper)
+    request.set(CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, index)
+    return applyRepeating()
+  }
+
+  fun setExposureLocked(locked: Boolean): Boolean {
+    val request = builder ?: return false
+    request.set(CaptureRequest.CONTROL_AE_LOCK, locked)
+    return applyRepeating()
+  }
+
+  /**
+   * Chống chớp đèn: mặc định HAL là AUTO — ROM đoán tần số lưới điện, và HyperOS
+   * đoán trật 60Hz trên lưới 50Hz là chuyện thường → AE chọn shutter lệch pha
+   * với nhịp đèn 100Hz, cả khung phập phồng. Ghim 50HZ là hết. Lưu ý: antibanding
+   * chỉ ràng buộc khi AE còn tự chạy — CONTROL_AE_LOCK bật thì giữ nguyên shutter
+   * đang có, khoá lúc đang lệch pha là khoá luôn cái chớp.
+   */
+  fun setAntibanding(mode: Int): Boolean {
+    val request = builder ?: return false
+    val modes = characteristics()
+      ?.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_ANTIBANDING_MODES)
+    if (modes?.contains(mode) != true) return false
+    request.set(CaptureRequest.CONTROL_AE_ANTIBANDING_MODE, mode)
+    return applyRepeating()
+  }
+
+  /** Khoá nét = chuyển về AUTO (dừng đảo nét); mở khoá = CONTINUOUS_VIDEO. */
+  fun setFocusLocked(locked: Boolean): Boolean {
+    val request = builder ?: return false
+    val modes = characteristics()?.get(CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES)
+      ?: return false
+    val target =
+      if (locked) CameraMetadata.CONTROL_AF_MODE_AUTO
+      else CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_VIDEO
+    if (!modes.contains(target)) return false
+    request.set(CaptureRequest.CONTROL_AF_MODE, target)
+    return applyRepeating()
+  }
+
+  fun setTorch(enabled: Boolean): Boolean {
+    val request = builder ?: return false
+    val available = characteristics()?.get(CameraCharacteristics.FLASH_INFO_AVAILABLE) ?: false
+    if (!available) return false
+    request.set(
+      CaptureRequest.FLASH_MODE,
+      if (enabled) CameraMetadata.FLASH_MODE_TORCH else CameraMetadata.FLASH_MODE_OFF,
+    )
+    return applyRepeating()
+  }
+}

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

@@ -0,0 +1,222 @@
+package expo.modules.pickleballrtmp
+
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.MediaCodec
+import android.media.MediaCodecInfo
+import android.media.MediaFormat
+import android.media.MediaRecorder
+import android.os.Bundle
+import android.view.Surface
+import java.nio.ByteBuffer
+
+/**
+ * Encoder H.264 nhận khung qua INPUT SURFACE — Camera2 ghi thẳng vào đó.
+ *
+ * Đây là điểm mấu chốt của kiến trúc mới: không có bước copy hay compose nào
+ * giữa cảm biến và encoder. Camera2 cho phép một capture session ghi ra nhiều
+ * surface song song, nên preview và encoder nhận CÙNG khung hình từ ISP.
+ */
+internal class VideoEncoder {
+  private var codec: MediaCodec? = null
+  private var drainThread: Thread? = null
+  @Volatile private var draining = false
+  @Volatile private var frameCount = 0L
+
+  var inputSurface: Surface? = null
+    private set
+
+  /** Số khung đã encode — dùng cho getStats().currentFps. */
+  val encodedFrames: Long get() = frameCount
+
+  fun prepare(width: Int, height: Int, fps: Int, bitrate: Int) {
+    release()
+    frameCount = 0
+    val format = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height).apply {
+      setInteger(
+        MediaFormat.KEY_COLOR_FORMAT,
+        MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface,
+      )
+      setInteger(MediaFormat.KEY_BIT_RATE, bitrate)
+      setInteger(MediaFormat.KEY_FRAME_RATE, fps)
+      // Keyframe 2 giây, khớp ranh giới segment HLS phía MediaMTX.
+      setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 2)
+      // CBR chứ không VBR mặc định: đo thực tế bản thử ra 7.47 Mbps khi đặt 6,
+      // và ở sân WiFi yếu thì vọt bitrate là nghẽn sớm hơn tính toán.
+      setInteger(
+        MediaFormat.KEY_BITRATE_MODE,
+        MediaCodecInfo.EncoderCapabilities.BITRATE_MODE_CBR,
+      )
+    }
+    codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC).apply {
+      configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
+      inputSurface = createInputSurface()
+    }
+  }
+
+  fun start(
+    onHeader: (sps: ByteBuffer, pps: ByteBuffer?) -> Unit,
+    onFrame: (ByteBuffer, MediaCodec.BufferInfo) -> Unit,
+  ) {
+    val active = codec ?: return
+    active.start()
+    draining = true
+    drainThread = Thread {
+      val info = MediaCodec.BufferInfo()
+      while (draining) {
+        val index = try {
+          active.dequeueOutputBuffer(info, 10_000)
+        } catch (error: IllegalStateException) {
+          break
+        }
+        when {
+          index == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
+            // Lấy SPS/PPS từ output format thay vì tự bóc start code trong
+            // buffer BUFFER_FLAG_CODEC_CONFIG — ít chỗ sai hơn.
+            val format = active.outputFormat
+            val sps = format.getByteBuffer("csd-0")
+            val pps = format.getByteBuffer("csd-1")
+            if (sps != null) onHeader(sps, pps)
+          }
+
+          index >= 0 -> {
+            val buffer = runCatching { active.getOutputBuffer(index) }.getOrNull()
+            val isConfig = info.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0
+            if (buffer != null && !isConfig && info.size > 0) {
+              frameCount++
+              onFrame(buffer, info)
+            }
+            runCatching { active.releaseOutputBuffer(index, false) }
+          }
+        }
+      }
+    }.also { it.start() }
+  }
+
+  /** Xin IDR ngay — để luồng bắt đầu bằng keyframe chứ không chờ tới 2 giây. */
+  fun requestKeyframe() {
+    runCatching {
+      codec?.setParameters(
+        Bundle().apply { putInt(MediaCodec.PARAMETER_KEY_REQUEST_SYNC_FRAME, 0) },
+      )
+    }
+  }
+
+  /** Đổi bitrate giữa luồng — KHÔNG khởi động lại encoder (sẽ thủng segment HLS). */
+  fun setBitrate(bitsPerSecond: Int) {
+    runCatching {
+      codec?.setParameters(
+        Bundle().apply { putInt(MediaCodec.PARAMETER_KEY_VIDEO_BITRATE, bitsPerSecond) },
+      )
+    }
+  }
+
+  fun release() {
+    draining = false
+    drainThread?.join(1_000)
+    drainThread = null
+    runCatching { codec?.stop() }
+    runCatching { codec?.release() }
+    codec = null
+    runCatching { inputSurface?.release() }
+    inputSurface = null
+  }
+}
+
+/**
+ * Mic → AAC. Tách hẳn khỏi video: tắt mic là dừng thu và dừng encode luôn, chứ
+ * không mute — giữ đúng hành vi cũ (`setMicrophoneEnabled` gỡ nguồn audio).
+ */
+internal class AudioEncoder {
+  private var codec: MediaCodec? = null
+  private var record: AudioRecord? = null
+  private var thread: Thread? = null
+  @Volatile private var running = false
+
+  fun prepare(bitrate: Int) {
+    release()
+    val format = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, SAMPLE_RATE, CHANNELS)
+      .apply {
+        setInteger(
+          MediaFormat.KEY_AAC_PROFILE,
+          MediaCodecInfo.CodecProfileLevel.AACObjectLC,
+        )
+        setInteger(MediaFormat.KEY_BIT_RATE, bitrate)
+        setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, BUFFER_SIZE)
+      }
+    codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC).apply {
+      configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
+    }
+  }
+
+  @Suppress("MissingPermission")
+  fun start(onFrame: (ByteBuffer, MediaCodec.BufferInfo) -> Unit) {
+    val active = codec ?: return
+    val minBuffer = AudioRecord.getMinBufferSize(
+      SAMPLE_RATE,
+      AudioFormat.CHANNEL_IN_MONO,
+      AudioFormat.ENCODING_PCM_16BIT,
+    ).coerceAtLeast(BUFFER_SIZE)
+    record = AudioRecord(
+      MediaRecorder.AudioSource.MIC,
+      SAMPLE_RATE,
+      AudioFormat.CHANNEL_IN_MONO,
+      AudioFormat.ENCODING_PCM_16BIT,
+      minBuffer,
+    )
+    active.start()
+    record?.startRecording()
+    running = true
+    thread = Thread {
+      val info = MediaCodec.BufferInfo()
+      val pcm = ByteArray(BUFFER_SIZE)
+      while (running) {
+        val read = record?.read(pcm, 0, pcm.size) ?: break
+        if (read > 0) {
+          val inputIndex = runCatching { active.dequeueInputBuffer(10_000) }.getOrDefault(-1)
+          if (inputIndex >= 0) {
+            runCatching {
+              val input = active.getInputBuffer(inputIndex)
+              input?.clear()
+              input?.put(pcm, 0, read)
+              active.queueInputBuffer(
+                inputIndex,
+                0,
+                read,
+                System.nanoTime() / 1_000,
+                0,
+              )
+            }
+          }
+        }
+        var outputIndex = runCatching { active.dequeueOutputBuffer(info, 0) }.getOrDefault(-1)
+        while (outputIndex >= 0) {
+          val buffer = runCatching { active.getOutputBuffer(outputIndex) }.getOrNull()
+          val isConfig = info.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0
+          if (buffer != null && !isConfig && info.size > 0) onFrame(buffer, info)
+          runCatching { active.releaseOutputBuffer(outputIndex, false) }
+          outputIndex = runCatching { active.dequeueOutputBuffer(info, 0) }.getOrDefault(-1)
+        }
+      }
+    }.also { it.start() }
+  }
+
+  fun release() {
+    running = false
+    thread?.join(1_000)
+    thread = null
+    runCatching { record?.stop() }
+    runCatching { record?.release() }
+    record = null
+    runCatching { codec?.stop() }
+    runCatching { codec?.release() }
+    codec = null
+  }
+
+  companion object {
+    const val SAMPLE_RATE = 44_100
+    const val CHANNELS = 1
+    const val IS_STEREO = false
+    private const val BUFFER_SIZE = 4_096
+  }
+}