blix-expo-settings 0.1.13 → 0.1.14

package/ios/ExpoSettingsModule.swift

@@ -2,57 +2,28 @@ import ExpoModulesCore
 import HaishinKit
 import AVFoundation
 import VideoToolbox
-import Logboard
-
-// MARK: - RTMP Event Observer
-
-final class RTMPEventObserver: NSObject {
-  var onStatus: ((String, String, String) -> Void)?
-  var onError: ((String) -> Void)?
-
-  @objc func rtmpStatusHandler(_ notification: Notification) {
-    let e: Event = Event.from(notification)
-    guard let data = e.data as? [String: Any] else { return }
-    let code = data["code"] as? String ?? ""
-    let level = data["level"] as? String ?? ""
-    let desc = data["description"] as? String ?? ""
-    onStatus?(code, level, desc)
-  }
-
-  @objc func rtmpErrorHandler(_ notification: Notification) {
-    let e: Event = Event.from(notification)
-    onError?("ioError: \(e)")
-  }
-}
-
-// MARK: - Module
 
 public class ExpoSettingsModule: Module {
   private var rtmpConnection: RTMPConnection?
   private var rtmpStream: RTMPStream?
-  private var currentStreamStatus: String = "stopped"
-  private let rtmpObserver = RTMPEventObserver()
-
-  private var pendingPublish: (url: String, streamKey: String)?
-  private var statsTimer: Timer?
-
-  // Timing/debug
-  private var previewInitTime: Date?
-  private var publishRequestTime: Date?
-  private var firstDataSentTime: Date?
-  private var stopRequestTime: Date?
-  private var lastDataSentTime: Date?
-
-  // Stream config
-  private let TARGET_ASPECT_RATIO: CGFloat = 9.0 / 16.0
-  private var calculatedVideoWidth: Int = 720
-  private var calculatedVideoHeight: Int = 1280
-  private var configuredBitrate: Int = 2_500_000
-  private var configuredFrameRate: Float64 = 30
-
-  // Monitor cancellation
-  private var dataMonitorToken: UUID?
-  private var stopFlushToken: UUID?
+  private var currentStatus: String = "idle"
+  private var operationStartTime: Date?
+
+  // 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 frameRate: Float64 = 30
+  private let gopSeconds: Int32 = 1
+
+  private static var audioSessionConfigured = false
+
+  private static let isoFormatter: ISO8601DateFormatter = {
+      let f = ISO8601DateFormatter()
+      f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+      return f
+  }()
 
   public func definition() -> ModuleDefinition {
     Name("ExpoSettings")
@@ -63,542 +34,252 @@ public class ExpoSettingsModule: Module {
       // não precisa colocar nada aqui se você não tiver Props
     }
 
-    Events("onStreamStatus", "onStreamStats", "onStreamTiming")
+   Events("onStreamStatus", "onStreamTiming")
 
     Function("getStreamStatus") {
       return self.currentStreamStatus
     }
 
-    Function("getStreamInfo") { () -> [String: Any] in
-      let w = self.calculatedVideoWidth
-      let h = self.calculatedVideoHeight
-      let ar = (h == 0) ? 0.0 : (Double(w) / Double(h))
-      return [
-        "videoWidth": w,
-        "videoHeight": h,
-        "aspectRatio": String(format: "%.4f", ar),
-        "bitrate": self.configuredBitrate,
-        "frameRate": self.configuredFrameRate
-      ]
-    }
-
-    Function("getDeviceDimensions") { () -> [String: Any] in
-      let screen = UIScreen.main.bounds
-      let scale = UIScreen.main.scale
-      return [
-        "screenWidth": Int(screen.width),
-        "screenHeight": Int(screen.height),
-        "scale": scale,
-        "pixelWidth": Int(screen.width * scale),
-        "pixelHeight": Int(screen.height * scale),
-        "streamWidth": self.calculatedVideoWidth,
-        "streamHeight": self.calculatedVideoHeight,
-        "aspectRatio": String(format: "%.4f", Double(self.calculatedVideoWidth) / Double(max(self.calculatedVideoHeight, 1)))
-      ]
-    }
-
-    Function("getStreamTiming") { () -> [String: Any] in
-      var result: [String: Any] = [:]
-      let fmt = ISO8601DateFormatter()
-
-      if let t = self.previewInitTime { result["previewInitTime"] = fmt.string(from: t) }
-      if let t = self.publishRequestTime { result["publishRequestTime"] = fmt.string(from: t) }
-      if let t = self.firstDataSentTime { result["firstDataSentTime"] = fmt.string(from: t) }
-      if let t = self.stopRequestTime { result["stopRequestTime"] = fmt.string(from: t) }
-      if let t = self.lastDataSentTime { result["lastDataSentTime"] = fmt.string(from: t) }
-
-      if let publish = self.publishRequestTime, let first = self.firstDataSentTime {
-        result["startDelayMs"] = Int(first.timeIntervalSince(publish) * 1000)
-      }
-
-      if let stop = self.stopRequestTime, let last = self.lastDataSentTime {
-        // Positive means stop happened after last data timestamp
-        result["timeSinceLastDataMs"] = Int(stop.timeIntervalSince(last) * 1000)
-      }
-
-      return result
-    }
-
-    Function("initializePreview") { () -> Void in
-      DispatchQueue.main.async { self.initializePreview() }
-    }
-
-    Function("publishStream") { (url: String, streamKey: String) -> Void in
-      DispatchQueue.main.async { self.publishStream(url: url, streamKey: streamKey) }
-    }
-
-    Function("stopStream") { () -> Void in
-      DispatchQueue.main.async { self.stopStream() }
-    }
-  }
-
-  // MARK: - Helpers
-
-  private func setStatus(_ s: String) {
-    guard currentStreamStatus != s else { return }
-    currentStreamStatus = s
-    sendEvent("onStreamStatus", [
-      "status": s,
-      "timestamp": ISO8601DateFormatter().string(from: Date())
-    ])
-  }
-
-  private func sanitizeRTMPUrl(_ url: String) -> String {
-    var u = url.trimmingCharacters(in: .whitespacesAndNewlines)
-    while u.hasSuffix("/") { u.removeLast() }
-    return u
-  }
-
-  private func calculateStreamDimensions() -> (width: Int, height: Int) {
-    let width = 720
-    let height = 1280
-
-    let aspectRatio = CGFloat(width) / CGFloat(height)
-    let expected = TARGET_ASPECT_RATIO
-
-    assert(abs(aspectRatio - expected) < 0.001, "Aspect ratio mismatch!")
-
-    print("[ExpoSettings] 📐 Stream dimensions: \(width)x\(height)")
-    print("[ExpoSettings] 📐 Aspect ratio: \(String(format: "%.4f", aspectRatio)) expected \(String(format: "%.4f", expected))")
-    return (width, height)
-  }
-
-  // MARK: - Permissions
-
-  private func requestAVPermissions(completion: @escaping (Bool) -> Void) {
-    let group = DispatchGroup()
-    var camOK = false
-    var micOK = false
-
-    group.enter()
-    AVCaptureDevice.requestAccess(for: .video) { granted in
-      camOK = granted
-      group.leave()
-    }
+        Function("initializePreview") {
+            Task { await self.initializePreview() }
+        }
 
-    group.enter()
-    AVCaptureDevice.requestAccess(for: .audio) { granted in
-      micOK = granted
-      group.leave()
-    }
+        Function("publishStream") { (url: String, streamKey: String) in
+            Task { await self.publishStream(url: url, streamKey: streamKey) }
+        }
 
-    group.notify(queue: .main) {
-      print("[ExpoSettings] camera permission \(camOK)")
-      print("[ExpoSettings] mic permission \(micOK)")
-      completion(camOK && micOK)
-    }
-  }
-
-  // MARK: - Preview init
-
-  private func initializePreview() {
-    previewInitTime = Date()
-    LBLogger.with("com.haishinkit.HaishinKit").level = .trace
-
-    print("[ExpoSettings] ⏱️ initializePreview at \(ISO8601DateFormatter().string(from: previewInitTime!))")
-    setStatus("previewInitializing")
-
-    requestAVPermissions { [weak self] ok in
-      guard let self else { return }
-      guard ok else {
-        print("[ExpoSettings] ❌ Missing camera/mic permissions")
-        self.setStatus("error")
-        return
-      }
-
-      // Audio session
-      let session = AVAudioSession.sharedInstance()
-      do {
-        try session.setCategory(.playAndRecord, mode: .default, options: [.defaultToSpeaker, .allowBluetooth])
-        try session.setPreferredSampleRate(44_100)
-        try session.setActive(true)
-        print("[ExpoSettings] ✅ AudioSession OK")
-      } catch {
-        print("[ExpoSettings] ❌ AudioSession error: \(error)")
-      }
-
-      let connection = RTMPConnection()
-      self.rtmpConnection = connection
-
-      let stream = RTMPStream(connection: connection)
-
-      // Attach listeners
-      connection.addEventListener(.rtmpStatus,
-                                 selector: #selector(RTMPEventObserver.rtmpStatusHandler(_:)),
-                                 observer: self.rtmpObserver)
-      connection.addEventListener(.ioError,
-                                 selector: #selector(RTMPEventObserver.rtmpErrorHandler(_:)),
-                                 observer: self.rtmpObserver)
-
-      stream.addEventListener(.rtmpStatus,
-                              selector: #selector(RTMPEventObserver.rtmpStatusHandler(_:)),
-                              observer: self.rtmpObserver)
-      stream.addEventListener(.ioError,
-                              selector: #selector(RTMPEventObserver.rtmpErrorHandler(_:)),
-                              observer: self.rtmpObserver)
-
-      self.rtmpStream = stream
-
-      self.rtmpObserver.onStatus = { [weak self] code, level, desc in
-        self?.handleRTMPStatus(code: code, level: level, desc: desc)
-      }
-      self.rtmpObserver.onError = { [weak self] msg in
-        print("[ExpoSettings] ❌ \(msg)")
-        self?.setStatus("error")
-      }
-
-      // Dimensions
-      let dimensions = self.calculateStreamDimensions()
-      self.calculatedVideoWidth = dimensions.width
-      self.calculatedVideoHeight = dimensions.height
-
-      // Video settings
-      self.configuredBitrate = 2_500_000
-      self.configuredFrameRate = 30
-
-        let videoSettings = VideoCodecSettings(
-        videoSize: CGSize(width: dimensions.width, height: dimensions.height),
-        bitRate: self.configuredBitrate,
-        profileLevel: kVTProfileLevel_H264_Baseline_3_1 as String,
-        scalingMode: .trim,
-        bitRateMode: .average,
-        maxKeyFrameIntervalDuration: 1, // GOP 1s
-        allowFrameReordering: nil,
-        isHardwareEncoderEnabled: true
-      )
-      stream.videoSettings = videoSettings
-      stream.frameRate = self.configuredFrameRate
-
-      print("[ExpoSettings] 📐 VideoSettings videoSize=\(stream.videoSettings.videoSize) bitrate=\(stream.videoSettings.bitRate) GOP=\(stream.videoSettings.maxKeyFrameIntervalDuration) fps=\(stream.frameRate)")
-
-      // Audio settings
-      var audioSettings = AudioCodecSettings()
-      audioSettings.bitRate = 128_000
-      stream.audioSettings = audioSettings
-      print("[ExpoSettings] 🔊 Audio bitRate: 128000")
-
-      // Devices
-      guard let camera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front) else {
-        print("[ExpoSettings] ❌ No front camera")
-        self.setStatus("error")
-        return
-      }
-      guard let microphone = AVCaptureDevice.default(for: .audio) else {
-        print("[ExpoSettings] ❌ No microphone")
-        self.setStatus("error")
-        return
-      }
-
-      // Attach camera (portrait, mirrored)
-      stream.attachCamera(camera) { videoUnit, error in
-        if let error = error {
-          print("[ExpoSettings] ❌ Camera ERROR: \(error)")
-        } else {
-          videoUnit?.isVideoMirrored = true
-          videoUnit?.videoOrientation = .portrait
-          print("[ExpoSettings] ✅ Camera attached (portrait, mirrored)")
+        Function("stopStream") {
+            Task { await self.stopStream() }
         }
-      }
 
-      stream.attachAudio(microphone) { _, error in
-        if let error = error {
-          print("[ExpoSettings] ❌ Audio ERROR: \(error.localizedDescription)")
-        } else {
-          print("[ExpoSettings] ✅ Audio attached")
+        Function("forceCleanup") {
+            self.cleanup()
+            self.setStatus("idle")
         }
-      }
-
-      // Attach preview
-      if let preview = ExpoSettingsView.current {
-        preview.attachStream(stream) // requires RTMPStream? in view to allow nil later
-        print("[ExpoSettings] ✅ Preview attached")
-      }
-
-      // Wait for encoder warm-up
-      DispatchQueue.main.asyncAfter(deadline: .now() + 1.2) { [weak self] in
-        guard let self, let s = self.rtmpStream else { return }
-        print("[ExpoSettings] 🔍 Warm verify videoSize=\(s.videoSettings.videoSize) fps=\(s.frameRate)")
-        self.setStatus("previewReady")
-        print("[ExpoSettings] ✅ Preview READY")
-      }
     }
-  }
 
-  // MARK: - Publish
+    private func setStatus(_ status: String) {
+        guard currentStatus != status else { return }
 
-  private func publishStream(url: String, streamKey: String) {
-    publishRequestTime = Date()
-    firstDataSentTime = nil
-    lastDataSentTime = nil
-    stopRequestTime = nil
+        print("[ExpoSettings] \(currentStatus) → \(status)")
+        currentStatus = status
 
-    // reset monitors
-    dataMonitorToken = UUID()
-
-    let cleanUrl = sanitizeRTMPUrl(url)
-    print("[ExpoSettings] ⏱️ publishStream at \(ISO8601DateFormatter().string(from: publishRequestTime!))")
-    print("[ExpoSettings]    URL: \(cleanUrl)")
-    print("[ExpoSettings]    Key: \(streamKey)")
-
-    guard let connection = rtmpConnection, let stream = rtmpStream else {
-      print("[ExpoSettings] ❌ No connection/stream")
-      setStatus("error")
-      return
+        sendEvent("onStreamStatus", [
+            "status": status,
+            "timestamp": Self.isoFormatter.string(from: Date())
+        ])
     }
 
-    print("[ExpoSettings] 🔍 Pre-publish videoSize=\(stream.videoSettings.videoSize)")
+    private func setupAudioSession() -> Bool {
 
-    pendingPublish = (cleanUrl, streamKey)
-    setStatus("connecting")
-    connection.connect(cleanUrl)
-  }
+        if Self.audioSessionConfigured { return true }
 
-  // MARK: - RTMP status
+        do {
+            let session = AVAudioSession.sharedInstance()
 
-  private func handleRTMPStatus(code: String, level: String, desc: String) {
-    let now = Date()
-    print("[ExpoSettings] ⏱️ RTMP status \(code) at \(ISO8601DateFormatter().string(from: now))")
+            try session.setCategory(
+                .playAndRecord,
+                mode: .default,
+                options: [.defaultToSpeaker, .allowBluetooth]
+            )
 
-    guard let stream = rtmpStream else { return }
+            try session.setActive(true)
 
-    switch code {
-    case "NetConnection.Connect.Success":
-      setStatus("connected")
-      if let p = pendingPublish {
-        pendingPublish = nil
-        setStatus("publishing")
-        print("[ExpoSettings] 📤 Publishing...")
-        stream.publish(p.streamKey, type: .live)
-
-        // Start monitoring for real media egress
-        monitorForRealOutboundMedia()
-      }
-
-    case "NetStream.Publish.Start":
-      // IMPORTANT:
-      // Do NOT setStatus("started") here anymore.
-      // This event means publish handshake started, not necessarily that DVR/RTMP has real media yet.
-      print("[ExpoSettings] ✅ Publish.Start received (waiting for data confirmation...)")
-
-    case "NetStream.Publish.BadName",
-         "NetStream.Publish.Rejected",
-         "NetConnection.Connect.Failed":
-      stopStatsTimer()
-      setStatus("error")
-
-    case "NetConnection.Connect.Closed":
-      stopStatsTimer()
-      setStatus("stopped")
-
-    default:
-      break
-    }
-  }
+            Self.audioSessionConfigured = true
+            print("[ExpoSettings] Audio session ready")
+            return true
 
-  // MARK: - Start confirmation (Fix #1)
+        } catch {
+            print("[ExpoSettings] Audio session error:", error)
+            return false
+        }
+    }
 
-  private func monitorForRealOutboundMedia() {
-    guard let connection = rtmpConnection, let stream = rtmpStream else { return }
-    let token = dataMonitorToken ?? UUID()
-    dataMonitorToken = token
+    private func initializePreview() async {
 
-    var checks = 0
-    let maxChecks = 200          // 20s (200 x 100ms)
-    let interval: TimeInterval = 0.1
+        print("[ExpoSettings] initializePreview")
+        operationStartTime = Date()
 
-    // Require a few consecutive "good" checks to avoid flapping
-    var goodStreak = 0
-    let neededGoodStreak = 4     // 400ms stable
+        cleanup()
+        try? await Task.sleep(nanoseconds: 200_000_000)
 
-    func tick() {
-      // cancelled?
-      guard self.dataMonitorToken == token else { return }
+        setStatus("previewInitializing")
 
-      checks += 1
+        guard setupAudioSession() else {
+            setStatus("error")
+            return
+        }
 
-      let bytesOut = connection.currentBytesOutPerSecond // Int32
-      let fps = stream.currentFPS
+        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
+        }
 
-      // Track last data time if any egress
-      if bytesOut > 0 && fps > 0 {
-        self.lastDataSentTime = Date()
-      }
+        // ---------- Audio ----------
+        stream.audioSettings = AudioCodecSettings(
+            bitRate: audioBitrate
+        )
+
+        // ---------- Video ----------
+        stream.videoSettings = VideoCodecSettings(
+            videoSize: .init(width: videoWidth, height: videoHeight),
+            bitRate: videoBitrate,
+            profileLevel: kVTProfileLevel_H264_Main_4_1 as String,
+            scalingMode: .letterbox,
+            bitRateMode: .average,
+            maxKeyFrameIntervalDuration: gopSeconds,
+            allowFrameReordering: nil,
+            isHardwareEncoderEnabled: true
+        )
+
+        // ---------- Attach Audio ----------
+        if let mic = AVCaptureDevice.default(for: .audio) {
+            stream.attachAudio(mic)
+        }
 
-      if bytesOut > 0 && fps > 0 {
-        goodStreak += 1
-      } else {
-        goodStreak = 0
-      }
+        // ---------- 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
+            }
+        }
 
-      // Confirm start ONLY when stable outbound is observed
-      if goodStreak >= neededGoodStreak {
-        if self.firstDataSentTime == nil {
-          self.firstDataSentTime = Date()
+        // ---------- Preview ----------
+        if let preview = await ExpoSettingsView.current {
+            await preview.attachStream(stream)
+        } else {
+            print("[ExpoSettings] ERROR: Preview view not found during publish!")
         }
 
-        let delayMs = self.publishRequestTime.flatMap { pub in
-          self.firstDataSentTime.map { Int($0.timeIntervalSince(pub) * 1000) }
-        } ?? -1
+        let ms = Int(Date().timeIntervalSince(operationStartTime!) * 1000)
 
-        print("[ExpoSettings] ✅ Data confirmed (bytesOut=\(bytesOut), fps=\(fps)) after \(delayMs)ms")
+        print("[ExpoSettings] Preview ready in \(ms)ms")
+        setStatus("previewReady")
 
-        // Emit timing events (send both names to match any JS)
-        self.sendEvent("onStreamTiming", [
-          "event": "dataConfirmed",
-          "delayMs": delayMs,
-          "timestamp": ISO8601DateFormatter().string(from: self.firstDataSentTime ?? Date())
-        ])
-        self.sendEvent("onStreamTiming", [
-          "event": "firstDataSent",
-          "delayMs": delayMs,
-          "timestamp": ISO8601DateFormatter().string(from: self.firstDataSentTime ?? Date())
+        sendEvent("onStreamTiming", [
+            "event": "previewReady",
+            "durationMs": ms
         ])
-
-        self.setStatus("started")
-        self.startStatsTimer()
-        return
-      }
-
-      // Timeout
-      if checks >= maxChecks {
-        print("[ExpoSettings] ⚠️ Start confirmation timeout (still no stable outbound media). Keeping status=\(self.currentStreamStatus)")
-        // Keep status as "publishing" or whatever it currently is; do not force started.
-        return
-      }
-
-      // Keep checking while in publishing/connected state
-      if self.currentStreamStatus == "publishing" || self.currentStreamStatus == "connected" || self.currentStreamStatus == "connecting" {
-        DispatchQueue.main.asyncAfter(deadline: .now() + interval) { tick() }
-      }
     }
 
-    tick()
-  }
+    private func publishStream(url: String, streamKey: String) async {
 
-  // MARK: - Stats
-
-  private func startStatsTimer() {
-    stopStatsTimer()
-    statsTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
-      guard let self,
-            let c = self.rtmpConnection,
-            let s = self.rtmpStream else { return }
+        guard let connection = rtmpConnection,
+              let stream = rtmpStream else {
+            setStatus("error")
+            return
+        }
 
-      let fps = s.currentFPS
-      let bps = c.currentBytesOutPerSecond * 8
+        operationStartTime = Date()
+        setStatus("connecting")
 
-      if bps > 0 {
-        self.lastDataSentTime = Date()
-      }
+        self.rtmpConnection?.connect(url)
 
-      self.sendEvent("onStreamStats", [
-        "fps": fps,
-        "bps": bps,
-        "timestamp": ISO8601DateFormatter().string(from: Date())
-      ])
-    }
-  }
+        let deadline = Date().addingTimeInterval(10)
 
-  private func stopStatsTimer() {
-    statsTimer?.invalidate()
-    statsTimer = nil
-  }
+        while Date() < deadline {
+            if connection.connected { break }
+            try? await Task.sleep(nanoseconds: 50_000_000)
+        }
 
-  // MARK: - Stop (Fix #2)
+        guard connection.connected else {
+            print("[ExpoSettings] Connect timeout")
+            setStatus("error")
+            return
+        }
 
-  private func stopStream() {
-    stopRequestTime = Date()
-    print("[ExpoSettings] ⏱️ stopStream at \(ISO8601DateFormatter().string(from: stopRequestTime!))")
+        setStatus("connected")
+        try? await Task.sleep(nanoseconds: 150_000_000)
 
-    // cancel start confirmation monitor
-    dataMonitorToken = UUID()
+        setStatus("publishing")
+        stream.publish(streamKey)
 
-    stopStatsTimer()
+        try? await Task.sleep(nanoseconds: 200_000_000)
 
-    guard let stream = rtmpStream, let connection = rtmpConnection else {
-      print("[ExpoSettings] No active stream to stop")
-      setStatus("stopped")
-      return
-    }
+        let ms = Int(Date().timeIntervalSince(operationStartTime!) * 1000)
 
-    setStatus("stopping")
+        print("[ExpoSettings] STREAM STARTED in \(ms)ms")
 
-    // Stop capturing new frames but keep connection open for flush
-    print("[ExpoSettings] 📤 Stop capture (keep RTMP open for flush)")
-    stream.attachCamera(nil) { _, _ in }
-    stream.attachAudio(nil) { _, _ in }
+        setStatus("started")
 
-    // Adaptive flush: wait until outbound bytes are ~0 for a stable window, OR max time reached
-    stopFlushToken = UUID()
-    let token = stopFlushToken!
+        sendEvent("onStreamTiming", [
+            "event": "firstDataSent",
+            "delayMs": ms,
+            "timestamp": Self.isoFormatter.string(from: Date())
+        ])
+    }
 
-    let interval: TimeInterval = 0.2
-    let maxFlushSeconds: TimeInterval = 12.0
-    let stableZeroNeeded: Int = 6     // 6 * 0.2s = 1.2s stable
+    private func stopStream() async {
 
-    var elapsed: TimeInterval = 0
-    var stableZeroCount = 0
+        print("[ExpoSettings] stopStream")
 
-    func flushTick() {
-      guard self.stopFlushToken == token else { return }
+        guard let stream = rtmpStream,
+              let connection = rtmpConnection else {
+            cleanup()
+            setStatus("stopped")
+            return
+        }
 
-      let bytesOut = connection.currentBytesOutPerSecond
-      let now = Date()
+        operationStartTime = Date()
+        setStatus("stopping")
 
-      // if still sending, update lastDataSentTime
-      if bytesOut > 0 {
-        self.lastDataSentTime = now
-        stableZeroCount = 0
-      } else {
-        stableZeroCount += 1
-      }
+        // Stop capture
+        stream.attachCamera(nil)
+        stream.attachAudio(nil)
 
-      elapsed += interval
+        // Flush encoder (GOP + 0.5s)
+        let flushNs = UInt64(gopSeconds) * 1_000_000_000 + 500_000_000
+        try? await Task.sleep(nanoseconds: flushNs)
 
-      // Condition to proceed: stable no outbound OR max wait
-      if stableZeroCount >= stableZeroNeeded || elapsed >= maxFlushSeconds {
-        print("[ExpoSettings] ✅ Flush condition met (stableZeroCount=\(stableZeroCount), elapsed=\(String(format: "%.1f", elapsed))s). Closing stream...")
+        // Close stream
+        stream.close()
+        try? await Task.sleep(nanoseconds: 300_000_000)
 
-        // Close stream then connection
-        self.rtmpStream?.close()
+        // Close socket
+        connection.close()
 
-        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
-          guard let self else { return }
-          self.rtmpConnection?.close()
+        cleanup()
 
-          DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
-            guard let self else { return }
+        let ms = Int(Date().timeIntervalSince(operationStartTime!) * 1000)
 
-            // Detach preview if your view supports optional
-            if let preview = ExpoSettingsView.current {
-              preview.attachStream(nil)
-            }
+        print("[ExpoSettings] STOPPED in \(ms)ms")
 
-            let finalTime = Date()
-            let totalMs = self.stopRequestTime.map { Int(finalTime.timeIntervalSince($0) * 1000) } ?? -1
+        setStatus("stopped")
 
-            self.sendEvent("onStreamTiming", [
-              "event": "shutdownComplete",
-              "totalDurationMs": totalMs,
-              "timestamp": ISO8601DateFormatter().string(from: finalTime)
-            ])
+        sendEvent("onStreamTiming", [
+            "event": "shutdownComplete",
+            "totalDurationMs": ms,
+            "timestamp": Self.isoFormatter.string(from: Date())
+        ])
+    }
 
-            self.rtmpStream = nil
-            self.rtmpConnection = nil
-            self.pendingPublish = nil
+    private func cleanup() {
 
-            self.setStatus("stopped")
-            print("[ExpoSettings] ✅ Stream stopped (total \(totalMs)ms)")
-          }
-        }
+        print("[ExpoSettings] Cleanup")
 
-        return
-      }
+        rtmpStream?.attachCamera(nil)
+        rtmpStream?.attachAudio(nil)
+        rtmpStream?.close()
+        rtmpStream = nil
 
-      // Keep flushing
-      DispatchQueue.main.asyncAfter(deadline: .now() + interval) { flushTick() }
+        rtmpConnection?.close()
+        rtmpConnection = nil
     }
-
-    flushTick()
-  }
 }

package/ios/ExpoSettingsView.swift

@@ -11,9 +11,6 @@ public class ExpoSettingsView: ExpoView {
     return view
   }()
 
-  // Guarda stream para reattach se a view recriar/layout mudar
-  private weak var attachedStream: RTMPStream?
-
   required init(appContext: AppContext? = nil) {
     super.init(appContext: appContext)
     clipsToBounds = true
@@ -27,10 +24,8 @@ public class ExpoSettingsView: ExpoView {
     hkView.frame = bounds
   }
 
-  // agora aceita nil
-  public func attachStream(_ stream: RTMPStream?) {
-    attachedStream = stream
-    hkView.attachStream(stream) // normalmente aceita nil
+  public func attachStream(_ stream: RTMPStream) {
+    hkView.attachStream(stream)
   }
 
   deinit {

package/package.json

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