blix-expo-settings 0.1.10 → 0.1.11

package/ios/ExpoSettingsModule.swift

@@ -8,10 +8,15 @@ public class ExpoSettingsModule: Module {
   private var rtmpStream: RTMPStream?
   private var currentStreamStatus: String = "stopped"
 
+
   public func definition() -> ModuleDefinition {
     Name("ExpoSettings")
 
-    View(ExpoSettingsView.self) {}
+    // 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")
 
@@ -20,165 +25,218 @@ public class ExpoSettingsModule: Module {
     }
 
     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 {
+      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
-
-        self.configureStream(stream)
-        self.attachAudioIfAvailable(stream)
-        self.attachFrontCamera(stream)
-        self.attachPreviewIfAvailable(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
+        }
+
+        // 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: 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.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)
+        self.currentStreamStatus = "previewReady"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
       }
+    }
 
-      if let connection = self.rtmpConnection {
-        connection.close()
+    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
+
+          // Create new stream
+          let stream = RTMPStream(connection: connection)
+          self.rtmpStream = 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])
+
+        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])
       }
-
-      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)
-    }
-  }
+    Function("stopStream") { () -> Void in
+      Task {
+        print("[ExpoSettings] stopStream called")
 
-  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")
-  }
+        // Primeiro pare a publicação (se estiver publicando)
+        if let stream = self.rtmpStream {
+          print("[ExpoSettings] Stopping stream publication")
+          stream.close()
 
-  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")
-    }
-  }
+          // Desanexa a câmera e o áudio para liberar recursos
+          stream.attachCamera(nil)
+          stream.attachAudio(nil)
+        }
 
-  private func attachFrontCamera(_ stream: RTMPStream) {
-    guard let camera = AVCaptureDevice.default(
-      .builtInWideAngleCamera,
-      for: .video,
-      position: .front
-    ) else {
-      print("[ExpoSettings] No front camera found")
-      return
-    }
+        // Depois feche a conexão RTMP
+        if let connection = self.rtmpConnection {
+          print("[ExpoSettings] Closing RTMP connection")
+          connection.close()
+        }
 
-    print("[ExpoSettings] Attaching front camera")
+        // Limpe as referências
+        self.rtmpStream = nil
+        self.rtmpConnection = nil
 
-    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
-    }
-  }
+        print("[ExpoSettings] Stream and connection closed and resources released")
 
-  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")
+        self.currentStreamStatus = "stopped"
+        sendEvent("onStreamStatus", ["status": self.currentStreamStatus])
       }
     }
   }

package/package.json

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