blix-expo-settings 0.1.9 → 0.1.11

package/ios/ExpoSettingsModule.swift

@@ -8,12 +8,14 @@ public class ExpoSettingsModule: Module {
   private var rtmpStream: RTMPStream?
   private var currentStreamStatus: String = "stopped"
 
+
   public func definition() -> ModuleDefinition {
     Name("ExpoSettings")
 
-    // View component (preview)
+    // Registra o view component para o admin se enxergar na live
+
     View(ExpoSettingsView.self) {
-      // sem props
+      // não precisa colocar nada aqui se você não tiver Props
     }
 
     Events("onStreamStatus")
@@ -24,65 +26,186 @@ public class ExpoSettingsModule: Module {
 
     Function("initializePreview") { () -> Void in
       Task {
-        self.setStatus("previewInitializing")
-
-        // 0) Configura AVAudioSession
-        self.configureAudioSession()
+        self.currentStreamStatus = "previewInitializing"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
+
+        do {
+
+        // 0) Configura e ativa o AVAudioSession
+        let session = AVAudioSession.sharedInstance()
+        do {
+          try session.setCategory(.playAndRecord,
+                                  mode: .default,
+                                  options: [.defaultToSpeaker, .allowBluetooth])
+          try session.setActive(true)
+        } catch {
+          print("[ExpoSettings] AVAudioSession error:", error)
+        }
 
-        // 1) Cria connection + stream
+        // 1) Conectar ao servidor RTMP, mas não publica
         let connection = RTMPConnection()
         self.rtmpConnection = connection
 
+        // 2) Criar RTMPStream, mas não publica pro servidor ainda
         let stream = RTMPStream(connection: connection)
         self.rtmpStream = stream
+        print("[ExpoSettings] RTMPStream initialized")
+
+        // 3) Configurar captura: frame rate e preset
+        stream.sessionPreset = .hd1280x720
+        stream.frameRate = 30
+        stream.videoOrientation = .portrait
+        stream.configuration { captureSession in
+          captureSession.automaticallyConfiguresApplicationAudioSession = true
+        }
 
-        // 2) Configura stream (tudo que influencia proporção/encode)
-        self.configureStream(stream)
-
-        // 3) Attach áudio
-        self.attachAudioIfAvailable(stream)
-
-        // 4) Attach câmera frontal (portrait + mirror)
-        await self.attachFrontCamera(stream)
+        // 4) Configurar áudio: anexa microfone
+        if let audioDevice = AVCaptureDevice.default(for: .audio) {
+          print("[ExpoSettings] Attaching audio device")
+          stream.attachAudio(audioDevice)
+        } else {
+          print("[ExpoSettings] No audio device found")
+        }
 
-        // 5) Attach preview (MainActor)
-        await self.attachPreviewIfAvailable(stream)
+        // 5) Configurar vídeo: anexa câmera frontal
+        if let camera = AVCaptureDevice.default(.builtInWideAngleCamera,
+                                               for: .video,
+                                               position: .front) {
+          print("[ExpoSettings] Attaching camera device")
+          stream.attachCamera(camera) { videoUnit, error in
+            guard let unit = videoUnit else {
+              print("[ExpoSettings] attachCamera error:", error?.localizedDescription ?? "unknown")
+              return
+            }
+            unit.isVideoMirrored = true
+            unit.videoOrientation = .portrait
+            unit.preferredVideoStabilizationMode = .standard
+            unit.colorFormat = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+
+          }
+          if let preview = await ExpoSettingsView.current {
+            print("[ExpoSettings] Attaching stream to preview view")
+            await preview.attachStream(stream)
+          } else {
+            print("[ExpoSettings] ERROR: Preview view not found!")
+          }
+        } else {
+          print("[ExpoSettings] No camera device found")
+        }
 
-        self.setStatus("previewReady")
+        //6) Definir configurações de codec
+        print("[ExpoSettings] Setting audio and video codecs")
+        var audioSettings = AudioCodecSettings()
+        audioSettings.bitRate = 128 * 1000
+        stream.audioSettings = audioSettings
+
+        let videoSettings = VideoCodecSettings(
+        videoSize: .init(width: 720, height: 1280),
+        bitRate: 4000 * 1000, 
+        profileLevel: kVTProfileLevel_H264_Baseline_3_1 as String,
+        scalingMode: .trim,
+        bitRateMode: .average,
+       maxKeyFrameIntervalDuration: 2,
+        allowFrameReordering: nil,
+        isHardwareEncoderEnabled: true
+        )
+        stream.videoSettings = videoSettings
+      }
+        self.currentStreamStatus = "previewReady"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
       }
     }
 
     Function("publishStream") { (url: String, streamKey: String) -> Void in
       Task {
+
         print("[ExpoSettings] Publishing stream to URL: \(url) with key: \(streamKey)")
-        self.setStatus("connecting")
 
-        // Caso não tenha initializePreview, cria do zero com config completa
-        if self.rtmpConnection == nil || self.rtmpStream == nil {
-          print("[ExpoSettings] WARNING: Connection or stream not initialized. Creating new ones.")
+        self.currentStreamStatus = "connecting"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
 
+        // se não houve initializePreview→recria a connection
+        if self.rtmpConnection == nil || self.rtmpStream == nil {
+          print("[ExpoSettings] WARNING: Connection or stream not initialized, creating new ones")
+          // Create new connection
           let connection = RTMPConnection()
           self.rtmpConnection = connection
 
+          // Create new stream
           let stream = RTMPStream(connection: connection)
           self.rtmpStream = stream
 
-          self.configureStream(stream)
-          self.attachAudioIfAvailable(stream)
-          await self.attachFrontCamera(stream)
-          await self.attachPreviewIfAvailable(stream)
+          // Captura: preset antes do FPS + orientação no stream
+          stream.sessionPreset = .hd1280x720
+          stream.frameRate = 30
+          stream.videoOrientation = .portrait
+          stream.configuration { captureSession in
+            captureSession.automaticallyConfiguresApplicationAudioSession = true
+          }
+
+          // Áudio
+          if let audioDevice = AVCaptureDevice.default(for: .audio) {
+            stream.attachAudio(audioDevice)
+          }
+
+          if let camera = AVCaptureDevice.default(.builtInWideAngleCamera,
+                                                 for: .video,
+                                                 position: .front) {
+            stream.attachCamera(camera) { videoUnit, error in
+              guard let unit = videoUnit else {
+                print("[ExpoSettings] attachCamera error:", error?.localizedDescription ?? "unknown")
+                return
+              }
+              unit.isVideoMirrored = true
+              unit.videoOrientation = .portrait
+              unit.preferredVideoStabilizationMode = .standard
+              unit.colorFormat = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+            }
+          }
+
+          // Attach preview (se existir)
+          if let preview = await ExpoSettingsView.current {
+            await preview.attachStream(stream)
+          } else {
+            print("[ExpoSettings] ERROR: Preview view not found during publish!")
+          }
+
+          var audioSettings = AudioCodecSettings()
+          audioSettings.bitRate = 128 * 1000 // 128 kbps
+          stream.audioSettings = audioSettings
+
+          // Vídeo
+          let videoSettings = VideoCodecSettings(
+            videoSize: .init(width: 720, height: 1280),
+            bitRate: 4000 * 1000, // 4 Mbps
+            profileLevel: kVTProfileLevel_H264_Baseline_3_1 as String,
+            scalingMode: .trim,
+            bitRateMode: .average,
+            maxKeyFrameIntervalDuration: 2,
+            allowFrameReordering: nil,
+            isHardwareEncoderEnabled: true
+          )
+          stream.videoSettings = videoSettings
+
+          self.currentStreamStatus = "previewReady"
+          sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
+          
+          connection.connect(url)
+        } else {
+          // Use existing connection
+          self.rtmpConnection?.connect(url)
         }
+        self.currentStreamStatus = "connected"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
 
-        // Conecta
-        self.rtmpConnection?.connect(url)
-        self.setStatus("connected")
+        self.currentStreamStatus = "publishing"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
 
-        // Publica
-        self.setStatus("publishing")
         self.rtmpStream?.publish(streamKey)
         print("[ExpoSettings] Stream published successfully")
 
-        self.setStatus("started")
+        self.currentStreamStatus = "started"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
       }
     }
 
@@ -90,114 +213,31 @@ public class ExpoSettingsModule: Module {
       Task {
         print("[ExpoSettings] stopStream called")
 
+        // Primeiro pare a publicação (se estiver publicando)
         if let stream = self.rtmpStream {
           print("[ExpoSettings] Stopping stream publication")
           stream.close()
 
-          // Libera recursos
+          // Desanexa a câmera e o áudio para liberar recursos
           stream.attachCamera(nil)
           stream.attachAudio(nil)
         }
 
+        // Depois feche a conexão RTMP
         if let connection = self.rtmpConnection {
           print("[ExpoSettings] Closing RTMP connection")
           connection.close()
         }
 
+        // Limpe as referências
         self.rtmpStream = nil
         self.rtmpConnection = nil
 
         print("[ExpoSettings] Stream and connection closed and resources released")
-        self.setStatus("stopped")
-      }
-    }
-  }
-
-  // MARK: - Helpers
-
-  private func setStatus(_ status: String) {
-    self.currentStreamStatus = status
-    sendEvent("onStreamStatus", ["status": status])
-  }
 
-  private func configureAudioSession() {
-    let session = AVAudioSession.sharedInstance()
-    do {
-      try session.setCategory(.playAndRecord,
-                              mode: .default,
-                              options: [.defaultToSpeaker, .allowBluetooth])
-      try session.setActive(true)
-    } catch {
-      print("[ExpoSettings] AVAudioSession error:", error)
-    }
-  }
-
-  /// Configuração centralizada do stream (evita mismatch entre preview/publish).
-  private func configureStream(_ stream: RTMPStream) {
-    print("[ExpoSettings] Configuring stream...")
-
-    // IMPORTANTE: preset primeiro, depois FPS (evita fallback estranho)
-    stream.sessionPreset = .hd1280x720
-    stream.frameRate = 30
-
-    // Orientação no nível do stream (governança do pipeline)
-    stream.videoOrientation = .portrait
-
-    // Sugestão para estabilidade de scaling/mix
-    stream.videoMixerSettings.mode = .offscreen
-
-    // Opcional: deixa o capture session gerenciar áudio automaticamente
-    stream.configuration { captureSession in
-      captureSession.automaticallyConfiguresApplicationAudioSession = true
-    }
-
-    // Áudio
-    var audioSettings = AudioCodecSettings()
-    audioSettings.bitRate = 128 * 1000
-    stream.audioSettings = audioSettings
-
-    // Vídeo (vertical 9:16)
-    // 720x1280 é um “sweet spot” pra compatibilidade e estabilidade
-    let videoSettings = VideoCodecSettings(
-      videoSize: .init(width: 720, height: 1280),
-      bitRate: 4_000 * 1000,
-      profileLevel: kVTProfileLevel_H264_Baseline_3_1 as String,
-      scalingMode: .trim, // sem distorção (corta excesso). Alternativa: .letterbox (barras)
-      bitRateMode: .average,
-      maxKeyFrameIntervalDuration: 2,
-      allowFrameReordering: nil,
-      isHardwareEncoderEnabled: true
-    )
-    stream.videoSettings = videoSettings
-
-    print("[ExpoSettings] Stream configured: preset=\(stream.sessionPreset.rawValue), fps=\(stream.frameRate), orientation=\(stream.videoOrientation.rawValue)")
-    print("[ExpoSettings] Encoder target: \(Int(videoSettings.videoSize.width))x\(Int(videoSettings.videoSize.height)) scaling=\(videoSettings.scalingMode.rawValue)")
-  }
-
-  private func attachAudioIfAvailable(_ stream: RTMPStream) {
-    if let audioDevice = AVCaptureDevice.default(for: .audio) {
-      print("[ExpoSettings] Attaching audio device")
-      stream.attachAudio(audioDevice)
-    } else {
-      print("[ExpoSettings] No audio device found")
+        self.currentStreamStatus = "stopped"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
+      }
     }
   }
-
-  private func attachFrontCamera(_ stream: RTMPStream) async {
-    guard let camera = AVCaptureDevice.default(.builtInWideAngleCamera,
-                                               for: .video,
-                                               position: .front) else {
-      print("[ExpoSettings] No front camera device found")
-      return
-    }
-
-    print("[ExpoSettings] Attaching front camera device")
-
-    stream.attachCamera(camera) { videoUnit, error in
-      guard let unit = videoUnit else {
-        print("[ExpoSettings] attachCamera error:", error?.localizedDescription ?? "unknown")
-        return
-      }
-
-      unit.isVideoMirrored = true
-      unit.videoOrientation = .po
+}

package/ios/ExpoSettingsView.swift

@@ -3,40 +3,34 @@ import HaishinKit
 import AVFoundation
 
 public class ExpoSettingsView: ExpoView {
-    
-    public static weak var current: ExpoSettingsView?
-    
-    // A view de preview do HaishinKit
-    private let hkView: MTHKView = {
-        let view = MTHKView(frame: .zero)
-        view.videoGravity = .resizeAspectFill
-        return view
-    }()
+  public static weak var current: ExpoSettingsView?
 
-    required init(appContext: AppContext? = nil) {
-        super.init(appContext: appContext)
-        clipsToBounds = true
-        addSubview(hkView)
-        ExpoSettingsView.current = self
-        print("[ExpoSettingsView] View initialized and set as current")
-    }
+  private let hkView: MTHKView = {
+    let view = MTHKView(frame: .zero)
+    view.videoGravity = .resizeAspectFill
+    return view
+  }()
 
-    override public func layoutSubviews() {
-        super.layoutSubviews()
-        hkView.frame = bounds
-        print("[ExpoSettingsView] Layout updated, frame: \(bounds)")
-    }
+  required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    clipsToBounds = true
+    addSubview(hkView)
+    ExpoSettingsView.current = self
+    print("[ExpoSettingsView] initialized")
+  }
 
-    /// Conecta o RTMPStream a essa view (internamente já faz o attachCamera + renderização)
-    public func attachStream(_ stream: RTMPStream) {
-        print("[ExpoSettingsView] Attaching stream to view")
-        hkView.attachStream(stream)
-    }
-    
-    deinit {
-        print("[ExpoSettingsView] View being deinitialized")
-        if ExpoSettingsView.current === self {
-            ExpoSettingsView.current = nil
-        }
+  public override func layoutSubviews() {
+    super.layoutSubviews()
+    hkView.frame = bounds
+  }
+
+  public func attachStream(_ stream: RTMPStream) {
+    hkView.attachStream(stream)
+  }
+
+  deinit {
+    if ExpoSettingsView.current === self {
+      ExpoSettingsView.current = nil
     }
+  }
 }

package/package.json

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