blix-expo-settings 0.1.15 → 0.1.16

package/ios/ExpoSettingsModule.swift

@@ -2,284 +2,378 @@ import ExpoModulesCore
 import HaishinKit
 import AVFoundation
 import VideoToolbox
+import Logboard
+import UIKit
+
+final class RTMPEventObserver: NSObject {
+  var onStatus: ((String) -> Void)?
+  var onError: ((String) -> Void)?
+
+  @objc func rtmpStatusHandler(_ notification: Notification) {
+    let e = Event.from(notification)
+    guard let data = e.data as? [String: Any], let code = data["code"] as? String else { return }
+    onStatus?(code)
+  }
+
+  @objc func rtmpErrorHandler(_ notification: Notification) {
+    onError?("ioError: \(Event.from(notification))")
+  }
+}
 
 public class ExpoSettingsModule: Module {
   private var rtmpConnection: RTMPConnection?
   private var rtmpStream: RTMPStream?
-  private var currentStatus: String = "idle"
-  private var operationStartTime: Date?
+  private var currentStreamStatus = "stopped"
+  private let rtmpObserver = RTMPEventObserver()
+  private var pendingPublish: (url: String, streamKey: String)?
+  private var statsTimer: Timer?
 
-  // MARK: - Stream Configuration (Portrait 9:16)
   private let videoWidth = 720
   private let videoHeight = 1280
-  private let videoBitrate = 4_000_000
-  private let audioBitrate = 128_000
+  private let videoBitrate = 6_000_000
+  private let audioBitrate = 160_000
   private let frameRate: Float64 = 30
-  private let gopSeconds: Int32 = 1
 
-  private static var audioSessionConfigured = false
+  // Timing buffers for Panda Video delays
+  private let startBufferSeconds: TimeInterval = 1.5  // Wait after publish before marking started
+  private let endBufferSeconds: TimeInterval = 10.0    // Keep streaming after stop requested
+// How long we tolerate the RTMP socket still sending after we detached
+  private let drainMaxSeconds: TimeInterval = 25.0   // hard upper bound to wait for remaining data
+  private let drainIdleSeconds: TimeInterval = 3.0   // consider drained after 3s with 0 Bps
 
-  private static let isoFormatter: ISO8601DateFormatter = {
-      let f = ISO8601DateFormatter()
-      f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
-      return f
-  }()
+  private var sessionId: UUID?
+  private var isInitialized = false
 
   public func definition() -> ModuleDefinition {
     Name("ExpoSettings")
+    View(ExpoSettingsView.self) {}
+    Events("onStreamStatus", "onStreamStats", "onStreamTiming")
 
-    // Registra o view component para o admin se enxergar na live
+    Function("getStreamStatus") { self.currentStreamStatus }
 
-    View(ExpoSettingsView.self) {
-      // não precisa colocar nada aqui se você não tiver Props
+    Function("getStreamInfo") { () -> [String: Any] in
+      ["videoWidth": self.videoWidth, "videoHeight": self.videoHeight,
+       "aspectRatio": String(format: "%.4f", Double(self.videoWidth) / Double(self.videoHeight)),
+       "bitrate": self.videoBitrate, "frameRate": self.frameRate]
     }
 
-   Events("onStreamStatus", "onStreamTiming")
-
-    Function("getStreamStatus") {
-      return self.currentStatus
+    Function("initializePreview") { DispatchQueue.main.async { self.initializePreview() } }
+    Function("publishStream") { (url: String, streamKey: String) in DispatchQueue.main.async { self.publishStream(url: url, streamKey: streamKey) } }
+    Function("stopStream") { DispatchQueue.main.async { self.stopStream() } }
+  }
+
+  private func setStatus(_ s: String) {
+    guard currentStreamStatus != s else { return }
+    currentStreamStatus = s
+    sendEvent("onStreamStatus", ["status": s, "timestamp": ISO8601DateFormatter().string(from: Date())])
+  }
+
+  private func initializePreview() {
+    LBLogger.with("com.haishinkit.HaishinKit").level = .trace
+    setStatus("previewInitializing")
+
+    let group = DispatchGroup()
+    var camOK = false, micOK = false
+
+    group.enter()
+    AVCaptureDevice.requestAccess(for: .video) { camOK = $0; group.leave() }
+    group.enter()
+    AVCaptureDevice.requestAccess(for: .audio) { micOK = $0; group.leave() }
+
+    group.notify(queue: .main) { [weak self] in
+      guard let self, camOK, micOK else { self?.setStatus("error"); return }
+
+      do {
+        let session = AVAudioSession.sharedInstance()
+        try session.setCategory(.playAndRecord, mode: .videoRecording, options: [.defaultToSpeaker, .allowBluetooth])
+        try session.setPreferredSampleRate(48000)
+        try session.setActive(true)
+      } catch {}
+
+      self.setupStream()
+      self.isInitialized = true
+      
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
+        self?.setStatus("previewReady")
+      }
     }
+  }
 
-        Function("initializePreview") {
-            Task { await self.initializePreview() }
-        }
+  private func setupStream() {
+    cleanupStream()
 
-        Function("publishStream") { (url: String, streamKey: String) in
-            Task { await self.publishStream(url: url, streamKey: streamKey) }
-        }
+    let connection = RTMPConnection()
+    let stream = RTMPStream(connection: connection)
 
-        Function("stopStream") {
-            Task { await self.stopStream() }
-        }
+    connection.addEventListener(.rtmpStatus, selector: #selector(RTMPEventObserver.rtmpStatusHandler(_:)), observer: rtmpObserver)
+    connection.addEventListener(.ioError, selector: #selector(RTMPEventObserver.rtmpErrorHandler(_:)), observer: rtmpObserver)
+    stream.addEventListener(.rtmpStatus, selector: #selector(RTMPEventObserver.rtmpStatusHandler(_:)), observer: rtmpObserver)
+    stream.addEventListener(.ioError, selector: #selector(RTMPEventObserver.rtmpErrorHandler(_:)), observer: rtmpObserver)
 
-        Function("forceCleanup") {
-            self.cleanup()
-            self.setStatus("idle")
-        }
-    }
+    rtmpConnection = connection
+    rtmpStream = stream
 
-    private func setStatus(_ status: String) {
-        guard currentStatus != status else { return }
-
-        print("[ExpoSettings] \(currentStatus) → \(status)")
-        currentStatus = status
-
-        sendEvent("onStreamStatus", [
-            "status": status,
-            "timestamp": Self.isoFormatter.string(from: Date())
-        ])
-    }
-
-    private func setupAudioSession() -> Bool {
-
-        if Self.audioSessionConfigured { return true }
-
-        do {
-            let session = AVAudioSession.sharedInstance()
-
-            try session.setCategory(
-                .playAndRecord,
-                mode: .default,
-                options: [.defaultToSpeaker, .allowBluetooth]
-            )
+    rtmpObserver.onStatus = { [weak self] code in self?.handleStatus(code) }
+    rtmpObserver.onError = { [weak self] _ in self?.setStatus("error") }
 
-            try session.setActive(true)
-
-            Self.audioSessionConfigured = true
-            print("[ExpoSettings] Audio session ready")
-            return true
-
-        } catch {
-            print("[ExpoSettings] Audio session error:", error)
-            return false
-        }
-    }
-
-    private func initializePreview() async {
-
-        print("[ExpoSettings] initializePreview")
-        operationStartTime = Date()
-
-        cleanup()
-        try? await Task.sleep(nanoseconds: 200_000_000)
-
-        setStatus("previewInitializing")
-
-        guard setupAudioSession() else {
-            setStatus("error")
-            return
-        }
-
-        let connection = RTMPConnection()
-        // 2) Criar RTMPStream, mas não publica pro servidor ainda
-        let stream = RTMPStream(connection: connection)
-        self.rtmpConnection = connection
-        self.rtmpStream = stream
-
-        // ---------- Stream Base ----------
-        stream.sessionPreset = .hd1280x720
-        stream.frameRate = frameRate
-        stream.videoOrientation = .portrait
-        stream.configuration { captureSession in
-          captureSession.automaticallyConfiguresApplicationAudioSession = true
-        }
-
-        // ---------- Audio ----------
-        stream.audioSettings = AudioCodecSettings(
-            bitRate: audioBitrate
-        )
-
-        // ---------- Video ----------
-        stream.videoSettings = VideoCodecSettings(
-            videoSize: .init(width: videoWidth, height: videoHeight),
+      if #available(iOS 16.0, *) {
+          stream.videoSettings = VideoCodecSettings(
+            videoSize: CGSize(width: videoWidth, height: videoHeight),
             bitRate: videoBitrate,
-            profileLevel: kVTProfileLevel_H264_Main_4_1 as String,
-            scalingMode: .letterbox,
+            profileLevel: kVTProfileLevel_H264_High_4_1 as String,
+            scalingMode: .trim,
+            bitRateMode: .constant,
+            maxKeyFrameIntervalDuration: 2,
+            allowFrameReordering: nil,
+            isHardwareEncoderEnabled: true
+          )
+      } else {
+          // Fallback on earlier versions
+          stream.videoSettings = VideoCodecSettings(
+            videoSize: CGSize(width: videoWidth, height: videoHeight),
+            bitRate: videoBitrate,
+            profileLevel: kVTProfileLevel_H264_High_4_1 as String,
+            scalingMode: .trim,
             bitRateMode: .average,
-            maxKeyFrameIntervalDuration: gopSeconds,
+            maxKeyFrameIntervalDuration: 2,
             allowFrameReordering: nil,
             isHardwareEncoderEnabled: true
-        )
+          )
+      }
+    stream.frameRate = frameRate
+
+    var audioSettings = AudioCodecSettings()
+    audioSettings.bitRate = audioBitrate
+    stream.audioSettings = audioSettings
+
+    guard let camera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front),
+          let mic = AVCaptureDevice.default(for: .audio) else {
+      setStatus("error")
+      return
+    }
 
-        // ---------- Attach Audio ----------
-        if let mic = AVCaptureDevice.default(for: .audio) {
-            stream.attachAudio(mic)
-        }
+    stream.attachCamera(camera) { unit, _ in
+      unit?.isVideoMirrored = true
+      unit?.videoOrientation = .portrait
+    }
+    stream.attachAudio(mic) { _, _ in }
 
-        // ---------- Attach Camera ----------
-        if let cam = AVCaptureDevice.default(
-            .builtInWideAngleCamera,
-            for: .video,
-            position: .front
-        ) {
-            stream.attachCamera(cam) { unit, _ in
-                guard let unit else { return }
-                unit.videoOrientation = .portrait
-                unit.isVideoMirrored = true
-                unit.preferredVideoStabilizationMode = .standard
-                unit.colorFormat = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
-            }
-        }
+    ExpoSettingsView.current?.attachStream(stream)
+  }
 
-        // ---------- Preview ----------
-        if let preview = await ExpoSettingsView.current {
-            await preview.attachStream(stream)
-        } else {
-            print("[ExpoSettings] ERROR: Preview view not found during publish!")
-        }
+  private func cleanupStream() {
+    if let c = rtmpConnection {
+      c.removeEventListener(.rtmpStatus, selector: #selector(RTMPEventObserver.rtmpStatusHandler(_:)), observer: rtmpObserver)
+      c.removeEventListener(.ioError, selector: #selector(RTMPEventObserver.rtmpErrorHandler(_:)), observer: rtmpObserver)
+    }
+    if let s = rtmpStream {
+      s.removeEventListener(.rtmpStatus, selector: #selector(RTMPEventObserver.rtmpStatusHandler(_:)), observer: rtmpObserver)
+      s.removeEventListener(.ioError, selector: #selector(RTMPEventObserver.rtmpErrorHandler(_:)), observer: rtmpObserver)
+    }
+    rtmpStream = nil
+    rtmpConnection = nil
+  }
 
-        let ms = Int(Date().timeIntervalSince(operationStartTime!) * 1000)
+  private func publishStream(url: String, streamKey: String) {
+    sessionId = UUID()
 
-        print("[ExpoSettings] Preview ready in \(ms)ms")
-        setStatus("previewReady")
+    var cleanUrl = url.trimmingCharacters(in: .whitespacesAndNewlines)
+    while cleanUrl.hasSuffix("/") { cleanUrl.removeLast() }
 
-        sendEvent("onStreamTiming", [
-            "event": "previewReady",
-            "durationMs": ms
-        ])
+    guard let connection = rtmpConnection, rtmpStream != nil else {
+      setStatus("error")
+      return
     }
 
-    private func publishStream(url: String, streamKey: String) async {
+    pendingPublish = (cleanUrl, streamKey)
+    setStatus("connecting")
+    connection.connect(cleanUrl)
+  }
 
-        guard let connection = rtmpConnection,
-              let stream = rtmpStream else {
-            setStatus("error")
-            return
-        }
+  private func handleStatus(_ code: String) {
+    let session = sessionId
+    guard let stream = rtmpStream else { return }
 
-        operationStartTime = Date()
-        setStatus("connecting")
+    switch code {
+    case "NetConnection.Connect.Success":
+      setStatus("connected")
+      if let p = pendingPublish {
+        pendingPublish = nil
+        setStatus("publishing")
+        stream.publish(p.streamKey, type: .live)
+      }
 
-        self.rtmpConnection?.connect(url)
+    case "NetStream.Publish.Start":
+      // Data is now flowing to Panda - wait for buffer before marking started
+      waitForStartBuffer(session: session)
 
-        let deadline = Date().addingTimeInterval(10)
+    case "NetStream.Publish.BadName", "NetStream.Publish.Rejected", "NetConnection.Connect.Failed":
+      stopStats()
+      setStatus("error")
 
-        while Date() < deadline {
-            if connection.connected { break }
-            try? await Task.sleep(nanoseconds: 50_000_000)
-        }
+    case "NetConnection.Connect.Closed":
+      stopStats()
+      if currentStreamStatus != "stopped" { setStatus("stopped") }
 
-        guard connection.connected else {
-            print("[ExpoSettings] Connect timeout")
-            setStatus("error")
-            return
+    default: break
+    }
+  }
+
+  private func waitForStartBuffer(session: UUID?) {
+    guard let connection = rtmpConnection, let stream = rtmpStream else { return }
+    
+    // Monitor until we confirm data is actually flowing
+    var checks = 0
+    let maxChecks = Int(startBufferSeconds * 10) // Check every 100ms
+    var dataConfirmed = false
+    
+    func checkData() {
+      guard self.sessionId == session else { return }
+      checks += 1
+      
+      let bytesOut = connection.currentBytesOutPerSecond
+      let fps = stream.currentFPS
+      
+      if bytesOut > 0 && fps > 0 {
+        dataConfirmed = true
+      }
+      
+      if checks >= maxChecks {
+        if dataConfirmed {
+          self.sendEvent("onStreamTiming", ["event": "started", "timestamp": ISO8601DateFormatter().string(from: Date())])
+          self.setStatus("started")
+          self.startStats()
+        } else {
+          // No data flowing after buffer - likely an error
+          self.setStatus("error")
         }
+        return
+      }
+      
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { checkData() }
+    }
+    
+    checkData()
+  }
+
+  private func startStats() {
+    stopStats()
+    statsTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+      guard let self, let c = self.rtmpConnection, let s = self.rtmpStream else { return }
+      self.sendEvent("onStreamStats", ["fps": s.currentFPS, "bps": c.currentBytesOutPerSecond * 8, "timestamp": ISO8601DateFormatter().string(from: Date())])
+    }
+  }
 
-        setStatus("connected")
-        try? await Task.sleep(nanoseconds: 150_000_000)
+  private func stopStats() {
+    statsTimer?.invalidate()
+    statsTimer = nil
+  }
 
-        setStatus("publishing")
-        stream.publish(streamKey)
+  // MARK: - Stop
+  private func stopStream() {
+    // Capture the session we are stopping
+    let session = sessionId
 
-        try? await Task.sleep(nanoseconds: 200_000_000)
+    guard let stream = rtmpStream, let connection = rtmpConnection else {
+      setStatus("stopped")
+      return
+    }
 
-        let ms = Int(Date().timeIntervalSince(operationStartTime!) * 1000)
+    setStatus("stopping")
+    stopStats()
 
-        print("[ExpoSettings] STREAM STARTED in \(ms)ms")
+    // 1) Keep capturing for a bit AFTER the user taps stop,
+    //    so Panda's "cut tail" window hits this extra content,
+    //    not the actual last seconds of the live.
+    DispatchQueue.main.asyncAfter(deadline: .now() + endBufferSeconds) { [weak self] in
+      guard let self = self, self.sessionId == session else { return }
 
-        setStatus("started")
+      // Stop producing new frames
+      stream.attachCamera(nil) { _, _ in }
+      stream.attachAudio(nil) { _, _ in }
 
-        sendEvent("onStreamTiming", [
-            "event": "firstDataSent",
-            "delayMs": ms,
-            "timestamp": Self.isoFormatter.string(from: Date())
-        ])
+      // 2) Now drain remaining bytes on the RTMP socket before closing
+      self.flushAndClose(stream: stream, connection: connection, session: session)
     }
-
-    private func stopStream() async {
-
-        print("[ExpoSettings] stopStream")
-
-        guard let stream = rtmpStream,
-              let connection = rtmpConnection else {
-            cleanup()
-            setStatus("stopped")
-            return
+  }
+
+  private func flushAndClose(stream: RTMPStream,
+                             connection: RTMPConnection,
+                             session: UUID?) {
+    let start = Date()
+    var idleStart: Date? = nil
+
+    func tick() {
+      // If a new stream started meanwhile, abort this drain
+      guard self.sessionId == session else { return }
+
+      let now = Date()
+      let elapsed = now.timeIntervalSince(start)
+
+      let bps = Double(connection.currentBytesOutPerSecond)
+
+      if bps > 0 {
+        // Still sending data – reset idle timer
+        idleStart = nil
+      } else {
+        // 0 Bps – start or continue idle period
+        if idleStart == nil {
+          idleStart = now
         }
+      }
 
-        operationStartTime = Date()
-        setStatus("stopping")
-
-        // Stop capture
-        stream.attachCamera(nil)
-        stream.attachAudio(nil)
-
-        // Flush encoder (GOP + 0.5s)
-        let flushNs = UInt64(gopSeconds) * 1_000_000_000 + 500_000_000
-        try? await Task.sleep(nanoseconds: flushNs)
+      let idle = idleStart.map { now.timeIntervalSince($0) } ?? 0
 
-        // Close stream
+      // Conditions to consider the stream fully drained:
+      //  - we have been idle (0 Bps) for drainIdleSeconds
+      //    OR
+      //  - we hit the absolute max wait (drainMaxSeconds)
+      if idle >= drainIdleSeconds || elapsed >= drainMaxSeconds {
+        // Close stream first
         stream.close()
-        try? await Task.sleep(nanoseconds: 300_000_000)
 
-        // Close socket
-        connection.close()
+        // Give HaishinKit a tiny moment to flush internal state
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+          guard let self = self else { return }
 
-        cleanup()
+          connection.close()
 
-        let ms = Int(Date().timeIntervalSince(operationStartTime!) * 1000)
+          // And a little extra before we emit final status / reset preview
+          DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+            guard let self = self, self.sessionId == session else { return }
 
-        print("[ExpoSettings] STOPPED in \(ms)ms")
-
-        setStatus("stopped")
-
-        sendEvent("onStreamTiming", [
-            "event": "shutdownComplete",
-            "totalDurationMs": ms,
-            "timestamp": Self.isoFormatter.string(from: Date())
-        ])
-    }
-
-    private func cleanup() {
+            self.sendEvent(
+              "onStreamTiming",
+              [
+                "event": "stopped",
+                "timestamp": ISO8601DateFormatter().string(from: Date())
+              ]
+            )
 
-        print("[ExpoSettings] Cleanup")
+            self.pendingPublish = nil
+            self.setStatus("stopped")
+
+            // Re-arm preview for the next live
+            if self.isInitialized {
+              self.setupStream()
+              DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+                if self?.currentStreamStatus == "stopped" {
+                  self?.setStatus("previewReady")
+                }
+              }
+            }
+          }
+        }
 
-        rtmpStream?.attachCamera(nil)
-        rtmpStream?.attachAudio(nil)
-        rtmpStream?.close()
-        rtmpStream = nil
+        return
+      }
 
-        rtmpConnection?.close()
-        rtmpConnection = nil
+      // Keep checking every 200 ms
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+        tick()
+      }
     }
-}
+
+    tick()
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blix-expo-settings",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "LiveStream",
   "main": "build/index.js",
   "types": "build/index.d.ts",