blix-expo-settings 0.1.8 → 0.1.10

package/ios/ExpoSettingsModule.swift

@@ -4,190 +4,182 @@ import AVFoundation
 import VideoToolbox
 
 public class ExpoSettingsModule: Module {
-    private var rtmpConnection: RTMPConnection?
-    private var rtmpStream: RTMPStream?
-    private var currentStreamStatus: String = "stopped"
-
-    
-    public func definition() -> ModuleDefinition {
-        Name("ExpoSettings")
-
-      // Registra o view component para o admin se enxergar na live
-
-        View(ExpoSettingsView.self) {
-          // não precisa colocar nada aqui se você não tiver Props
-        }
-        
-        Events("onStreamStatus")
-
-        Function("getStreamStatus") {
-          return self.currentStreamStatus
-        }
-
-        Function("initializePreview") { () -> Void in
-              Task {
-                  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) 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.frameRate = 30
-                    stream.sessionPreset = .high
-                    stream.configuration { captureSession in
-                      captureSession.automaticallyConfiguresApplicationAudioSession = true
-                    }
-                    
-                    // 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) 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")
-                    }
-
-                    //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: 1080, height: 1920),
-                     bitRate: 4000 * 1000, 
-                     profileLevel: kVTProfileLevel_H264_Baseline_4_0 as String,
-                     scalingMode: .letterbox,
-                     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.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
-                   connection.connect(url)
-                   
-                   // Create new stream
-                   let stream = RTMPStream(connection: connection)
-                   self.rtmpStream = stream
-                   
-                   // Attach to view if available
-                   if let preview = await ExpoSettingsView.current {
-                       await preview.attachStream(stream)
-                   } else {
-                       print("[ExpoSettings] ERROR: Preview view not found during publish!")
-                   }
-               } else {
-                   // Use existing connection
-                   self.rtmpConnection?.connect(url)
-               }
-               self.currentStreamStatus = "connected"
-               sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
-
-              self.currentStreamStatus = "publishing"
-               sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
-
-               self.rtmpStream?.publish(streamKey)
-               print("[ExpoSettings] Stream published successfully")
-
-               self.currentStreamStatus = "started"
-               sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
-              }
-            }
-
-              Function("stopStream") { () -> Void in
-                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()
-                        
-                        // 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.currentStreamStatus = "stopped"
-                    sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
-                }
-            }
-        }
-    }
+  private var rtmpConnection: RTMPConnection?
+  private var rtmpStream: RTMPStream?
+  private var currentStreamStatus: String = "stopped"
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoSettings")
+
+    View(ExpoSettingsView.self) {}
+
+    Events("onStreamStatus")
+
+    Function("getStreamStatus") {
+      return self.currentStreamStatus
+    }
+
+    Function("initializePreview") { () -> Void in
+      self.setStatus("previewInitializing")
+
+      self.configureAudioSession()
+
+      let connection = RTMPConnection()
+      self.rtmpConnection = connection
+
+      let stream = RTMPStream(connection: connection)
+      self.rtmpStream = stream
+
+      self.configureStream(stream)
+      self.attachAudioIfAvailable(stream)
+      self.attachFrontCamera(stream)
+      self.attachPreviewIfAvailable(stream)
+
+      self.setStatus("previewReady")
+    }
+
+    Function("publishStream") { (url: String, streamKey: String) -> Void in
+      self.setStatus("connecting")
+      print("[ExpoSettings] Publishing to: \(url) key: \(streamKey)")
+
+      // Se não existe stream/connection, cria e aplica TODA a config
+      if self.rtmpConnection == nil || self.rtmpStream == nil {
+        let connection = RTMPConnection()
+        self.rtmpConnection = connection
+
+        let stream = RTMPStream(connection: connection)
+        self.rtmpStream = stream
+
+        self.configureStream(stream)
+        self.attachAudioIfAvailable(stream)
+        self.attachFrontCamera(stream)
+        self.attachPreviewIfAvailable(stream)
+      }
+
+      self.rtmpConnection?.connect(url)
+      self.setStatus("connected")
+
+      self.setStatus("publishing")
+      self.rtmpStream?.publish(streamKey)
+
+      self.setStatus("started")
+    }
+
+    Function("stopStream") { () -> Void in
+      print("[ExpoSettings] stopStream called")
+
+      if let stream = self.rtmpStream {
+        stream.close()
+        stream.attachCamera(nil)
+        stream.attachAudio(nil)
+      }
+
+      if let connection = self.rtmpConnection {
+        connection.close()
+      }
+
+      self.rtmpStream = nil
+      self.rtmpConnection = nil
+
+      self.setStatus("stopped")
+    }
+  }
+
+  // MARK: - Internals
+
+  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)
+    }
+  }
+
+  private func configureStream(_ stream: RTMPStream) {
+    print("[ExpoSettings] Configuring stream...")
+
+    // 1) Captura previsível (16:9)
+    stream.sessionPreset = .hd1280x720
+    stream.frameRate = 30
+
+    // 2) Orientação no nível do stream (governa pipeline)
+    stream.videoOrientation = .portrait
+
+    // 3) Áudio
+    var audioSettings = AudioCodecSettings()
+    audioSettings.bitRate = 128 * 1000
+    stream.audioSettings = audioSettings
+
+    // 4) Vídeo (9:16). Use 720x1280 para 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). 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)")
+    print("[ExpoSettings] Target=\(Int(videoSettings.videoSize.width))x\(Int(videoSettings.videoSize.height)) orientation=portrait")
+  }
+
+  private func attachAudioIfAvailable(_ stream: RTMPStream) {
+    if let audioDevice = AVCaptureDevice.default(for: .audio) {
+      print("[ExpoSettings] Attaching audio")
+      stream.attachAudio(audioDevice)
+    } else {
+      print("[ExpoSettings] No audio device found")
+    }
+  }
+
+  private func attachFrontCamera(_ stream: RTMPStream) {
+    guard let camera = AVCaptureDevice.default(
+      .builtInWideAngleCamera,
+      for: .video,
+      position: .front
+    ) else {
+      print("[ExpoSettings] No front camera found")
+      return
+    }
+
+    print("[ExpoSettings] Attaching front camera")
+
+    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   // <-- GARANTA que está .portrait (não .po)
+      unit.preferredVideoStabilizationMode = .standard
+      unit.colorFormat = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+    }
+  }
+
+  private func attachPreviewIfAvailable(_ stream: RTMPStream) {
+    DispatchQueue.main.async {
+      if let preview = ExpoSettingsView.current {
+        print("[ExpoSettings] Attaching stream to preview")
+        preview.attachStream(stream)
+      } else {
+        print("[ExpoSettings] Preview not available yet")
+      }
+    }
+  }
+}

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.8",
+  "version": "0.1.10",
   "description": "LiveStream",
   "main": "build/index.js",
   "types": "build/index.d.ts",