blix-expo-settings 0.1.8 → 0.1.9

package/ios/ExpoSettingsModule.swift

@@ -4,190 +4,200 @@ import AVFoundation
 import VideoToolbox
 
 public class ExpoSettingsModule: Module {
-    private var rtmpConnection: RTMPConnection?
-    private var rtmpStream: RTMPStream?
-    private var currentStreamStatus: String = "stopped"
+  private var rtmpConnection: RTMPConnection?
+  private var rtmpStream: RTMPStream?
+  private var currentStreamStatus: String = "stopped"
 
-    
-    public func definition() -> ModuleDefinition {
-        Name("ExpoSettings")
+  public func definition() -> ModuleDefinition {
+    Name("ExpoSettings")
 
-      // Registra o view component para o admin se enxergar na live
+    // View component (preview)
+    View(ExpoSettingsView.self) {
+      // sem props
+    }
 
-        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.setStatus("previewInitializing")
+
+        // 0) Configura AVAudioSession
+        self.configureAudioSession()
+
+        // 1) Cria connection + stream
+        let connection = RTMPConnection()
+        self.rtmpConnection = connection
+
+        let stream = RTMPStream(connection: connection)
+        self.rtmpStream = stream
+
+        // 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)
+
+        // 5) Attach preview (MainActor)
+        await self.attachPreviewIfAvailable(stream)
+
+        self.setStatus("previewReady")
+      }
+    }
+
+    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.")
+
+          let connection = RTMPConnection()
+          self.rtmpConnection = connection
+
+          let stream = RTMPStream(connection: connection)
+          self.rtmpStream = stream
+
+          self.configureStream(stream)
+          self.attachAudioIfAvailable(stream)
+          await self.attachFrontCamera(stream)
+          await self.attachPreviewIfAvailable(stream)
         }
-        
-        Events("onStreamStatus")
 
-        Function("getStreamStatus") {
-          return self.currentStreamStatus
+        // Conecta
+        self.rtmpConnection?.connect(url)
+        self.setStatus("connected")
+
+        // Publica
+        self.setStatus("publishing")
+        self.rtmpStream?.publish(streamKey)
+        print("[ExpoSettings] Stream published successfully")
+
+        self.setStatus("started")
+      }
+    }
+
+    Function("stopStream") { () -> Void in
+      Task {
+        print("[ExpoSettings] stopStream called")
+
+        if let stream = self.rtmpStream {
+          print("[ExpoSettings] Stopping stream publication")
+          stream.close()
+
+          // Libera recursos
+          stream.attachCamera(nil)
+          stream.attachAudio(nil)
         }
 
-        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])
-                }
-            }
+        if let connection = self.rtmpConnection {
+          print("[ExpoSettings] Closing RTMP connection")
+          connection.close()
         }
-    }
+
+        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")
+    }
+  }
+
+  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/package.json

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