@pickleball/rtmp-native 0.1.0 → 0.2.0

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

@@ -1,61 +1,157 @@
 package expo.modules.pickleballrtmp
 
 import android.content.Context
+import android.view.Surface
+import android.view.SurfaceHolder
+import android.view.SurfaceView
 import android.view.ViewGroup
-import com.haishinkit.media.MediaMixer
-import com.haishinkit.view.HkSurfaceView
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.views.ExpoView
 
 /**
- * Nối view preview với mixer bất kể bên nào sẵn sàng trước.
+ * Preview = SurfaceView THUẦN. Camera2 ghi thẳng vào surface này.
  *
- * React mount view và JS gọi prepare() theo thứ tự không đoán trước được; giữ
- * tham chiếu ở đây để bên đến sau tự bắt được bên đến trước. Thiếu cơ chế này
- * thì màn hình đen dù camera đã chạy — đúng lỗi đã gặp trên iOS.
+ * Trước đây đây là HkSurfaceView nhận khung đã qua mixer GL của HaishinKit —
+ * chính tầng đó gây răng cưa (xem ghi chú kiến trúc trong
+ * PickleballRtmpNativeModule). Giờ không còn texture trung gian nào: ISP đổ
+ * khung vào surface này và vào surface của encoder song song, trong cùng một
+ * capture session.
+ *
+ * Hệ quả phụ đáng giá: cái thấy trên màn hình đúng bằng cái được mã hoá, vì cả
+ * hai lấy từ cùng một nguồn chứ không phải cùng một bản compose.
  */
 object PickleballRtmpPreviewRegistry {
-  private var mixer: MediaMixer? = null
-  private var view: HkSurfaceView? = null
+  private var surface: Surface? = null
+  private var listener: ((Surface?) -> Unit)? = null
+
+  /** Kích thước buffer preview — đặt bằng đúng cỡ capture để không phải scale. */
+  private var width = 1920
+  private var height = 1080
+  private var holder: SurfaceHolder? = null
+
+  @Synchronized
+  fun setBufferSize(w: Int, h: Int) {
+    width = w
+    height = h
+    holder?.setFixedSize(w, h)
+  }
 
   @Synchronized
-  fun setMixer(value: MediaMixer?) {
-    mixer = value
-    bind()
+  fun attach(target: SurfaceHolder?) {
+    holder = target
+    target?.setFixedSize(width, height)
   }
 
   @Synchronized
-  fun setView(value: HkSurfaceView?) {
-    view?.let { previous -> mixer?.unregisterOutput(previous) }
-    view = value
-    bind()
+  fun publish(value: Surface?) {
+    surface = value
+    listener?.invoke(value)
   }
 
-  private fun bind() {
-    val currentMixer = mixer ?: return
-    val currentView = view ?: return
-    currentMixer.registerOutput(currentView)
+  /**
+   * Module đăng ký để biết surface sẵn sàng. View mount và prepare() gọi theo
+   * thứ tự không đoán trước được, nên bên đến sau phải bắt được bên đến trước —
+   * gọi callback ngay nếu surface đã có.
+   */
+  @Synchronized
+  fun observe(callback: ((Surface?) -> Unit)?) {
+    listener = callback
+    callback?.invoke(surface)
   }
+
+  @Synchronized
+  fun current(): Surface? = surface
+
+  /**
+   * SurfaceView đang hiển thị — snapshot PHẢI dùng bản PixelCopy nhận
+   * SurfaceView chứ không phải bản nhận Surface: bản Surface đọc buffer THÔ,
+   * còn camera ghi theo hướng cảm biến (SENSOR_ORIENTATION=90) và phép xoay do
+   * SurfaceFlinger áp lúc hiển thị. Đọc buffer thô = ảnh lệch 90°.
+   */
+  @Synchronized
+  fun view(): SurfaceView? = viewRef
+
+  private var viewRef: SurfaceView? = null
+
+  @Synchronized
+  fun setView(value: SurfaceView?) {
+    viewRef = value
+  }
+
+  @Synchronized
+  fun bufferAspect(): Float = width.toFloat() / height.toFloat()
+
+  /**
+   * Kích thước THẬT của buffer preview (đúng cỡ capture, VD 1920x1080).
+   *
+   * snapshot() phải cấp bitmap đúng cỡ này: PixelCopy SCALE nội dung surface
+   * vào bitmap đích, nên cấp theo kích thước VIEW (đang dọc theo màn hình máy)
+   * là ép khung ngang vào khung dọc — ảnh méo, và xoay xong vẫn méo.
+   */
+  @Synchronized
+  fun bufferSize(): Pair<Int, Int> = width to height
 }
 
 class PickleballRtmpPreviewView(
   context: Context,
   appContext: AppContext,
 ) : ExpoView(context, appContext) {
-  private val surface = HkSurfaceView(context).also {
-    it.layoutParams = ViewGroup.LayoutParams(
+  private val surfaceView = SurfaceView(context).also { view ->
+    view.layoutParams = ViewGroup.LayoutParams(
       ViewGroup.LayoutParams.MATCH_PARENT,
       ViewGroup.LayoutParams.MATCH_PARENT,
     )
-    addView(it)
+    view.holder.addCallback(
+      object : SurfaceHolder.Callback {
+        override fun surfaceCreated(holder: SurfaceHolder) {
+          PickleballRtmpPreviewRegistry.attach(holder)
+        }
+
+        override fun surfaceChanged(holder: SurfaceHolder, f: Int, w: Int, h: Int) {
+          PickleballRtmpPreviewRegistry.publish(holder.surface)
+        }
+
+        override fun surfaceDestroyed(holder: SurfaceHolder) {
+          PickleballRtmpPreviewRegistry.attach(null)
+          PickleballRtmpPreviewRegistry.publish(null)
+        }
+      },
+    )
+    addView(view)
   }
 
   init {
-    PickleballRtmpPreviewRegistry.setView(surface)
+    // Giữ màn hình sáng suốt thời gian preview hiển thị — kể cả lúc standby chờ
+    // lệnh publish. Keep-awake phía JS chỉ bật trong phiên (enterSession).
+    keepScreenOn = true
+    PickleballRtmpPreviewRegistry.setView(surfaceView)
   }
 
   override fun onDetachedFromWindow() {
     PickleballRtmpPreviewRegistry.setView(null)
     super.onDetachedFromWindow()
   }
+
+  /**
+   * Letterbox thay vì kéo giãn.
+   *
+   * SurfaceView để MATCH_PARENT thì SurfaceFlinger kéo buffer 16:9 cho đầy màn
+   * 21.9:9 của máy — giãn ngang 1.246x, méo hình. Tự đo và căn giữa theo đúng
+   * tỉ lệ buffer để cái nhìn thấy = cái được mã hoá.
+   */
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    val width = r - l
+    val height = b - t
+    if (width <= 0 || height <= 0) return
+    val aspect = PickleballRtmpPreviewRegistry.bufferAspect()
+    var childWidth = width
+    var childHeight = (width / aspect).toInt()
+    if (childHeight > height) {
+      childHeight = height
+      childWidth = (height * aspect).toInt()
+    }
+    val left = (width - childWidth) / 2
+    val top = (height - childHeight) / 2
+    surfaceView.layout(left, top, left + childWidth, top + childHeight)
+  }
 }

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

@@ -0,0 +1,126 @@
+package expo.modules.pickleballrtmp
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+
+/**
+ * Foreground service GIỮ TIẾN TRÌNH SỐNG suốt thời gian camera đang mở.
+ *
+ * Vì sao cần: máy này là camera đặt cố định ở sân, không phải app cầm tay. Khoá
+ * màn hình hay chuyển sang app khác một lúc là Android (HyperOS của Xiaomi đặc
+ * biệt hung) giết tiến trình — đo thực tế: cho ra nền 10 GIÂY là PID đã đổi
+ * 5155 → 6070. Tiến trình chết thì phiên mồ côi, mở lại app phải tạo phiên mới:
+ * đúng triệu chứng "thoát app vào lại là mất phiên".
+ *
+ * Service này CỐ Ý không làm gì ngoài việc tồn tại. Toàn bộ camera/encoder/RTMP
+ * vẫn do PickleballRtmpNativeModule sở hữu — service chỉ nâng mức ưu tiên tiến
+ * trình và khai báo hai loại FGS `camera`+`microphone` để Android 14+ cho phép
+ * app tiếp tục dùng camera và mic khi không ở tiền cảnh.
+ *
+ * START_NOT_STICKY chứ KHÔNG phải START_STICKY: nếu tiến trình vẫn chết, khởi
+ * động lại mỗi service mà không có React state đi kèm chỉ tạo ra một cái vỏ giữ
+ * thông báo vĩnh viễn, không giữ được gì.
+ */
+class PickleballRtmpService : Service() {
+  override fun onBind(intent: Intent?): IBinder? = null
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    if (intent?.action == ACTION_STOP) {
+      stopSelf()
+      return START_NOT_STICKY
+    }
+    startInForeground()
+    return START_NOT_STICKY
+  }
+
+  private fun startInForeground() {
+    ensureChannel()
+    val notification: Notification = NotificationCompat.Builder(this, CHANNEL_ID)
+      .setContentTitle(appLabel())
+      .setContentText("Camera đang hoạt động")
+      .setSmallIcon(android.R.drawable.presence_video_online)
+      // Ongoing + LOW: không kêu, không rung, người dùng không vuốt bỏ được.
+      .setOngoing(true)
+      .setPriority(NotificationCompat.PRIORITY_LOW)
+      .setContentIntent(launchIntent())
+      .build()
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      startForeground(
+        NOTIFICATION_ID,
+        notification,
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA or
+          ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE,
+      )
+    } else {
+      startForeground(NOTIFICATION_ID, notification)
+    }
+  }
+
+  /** Bấm vào thông báo → quay lại app, không mở activity mới. */
+  private fun launchIntent(): PendingIntent? {
+    val intent = packageManager.getLaunchIntentForPackage(packageName) ?: return null
+    return PendingIntent.getActivity(
+      this,
+      0,
+      intent,
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+    )
+  }
+
+  private fun appLabel(): String =
+    runCatching { applicationInfo.loadLabel(packageManager).toString() }
+      .getOrDefault("Camera")
+
+  private fun ensureChannel() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+    val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (manager.getNotificationChannel(CHANNEL_ID) != null) return
+    manager.createNotificationChannel(
+      NotificationChannel(
+        CHANNEL_ID,
+        "Camera trực tiếp",
+        NotificationManager.IMPORTANCE_LOW,
+      ).apply {
+        description = "Giữ camera chạy khi app ở nền"
+        setShowBadge(false)
+      },
+    )
+  }
+
+  companion object {
+    private const val NOTIFICATION_ID = 0x9C41
+    private const val CHANNEL_ID = "pickleball-rtmp-camera"
+    private const val ACTION_STOP = "expo.modules.pickleballrtmp.STOP"
+
+    /**
+     * PHẢI gọi khi app còn ở tiền cảnh. Từ Android 12 (S), khởi động foreground
+     * service từ nền ném ForegroundServiceStartNotAllowedException — nên điểm gọi
+     * là prepare(), lúc người dùng vừa mở màn camera.
+     */
+    fun start(context: Context) {
+      val intent = Intent(context, PickleballRtmpService::class.java)
+      runCatching {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          context.startForegroundService(intent)
+        } else {
+          context.startService(intent)
+        }
+      }
+    }
+
+    fun stop(context: Context) {
+      runCatching {
+        context.stopService(Intent(context, PickleballRtmpService::class.java))
+      }
+    }
+  }
+}