@stream-io/video-react-native-sdk 1.29.4-beta.0 → 1.30.0

package/ios/RTCViewPip.swift

@@ -10,11 +10,85 @@ import React
 
 @objc(RTCViewPip)
 class RTCViewPip: UIView {
-    
-    private var pictureInPictureController = StreamPictureInPictureController()
+
+    private var pictureInPictureController: StreamPictureInPictureController? = StreamPictureInPictureController()
     private var webRtcModule: WebRTCModule?
-    
+
     @objc var onPiPChange: RCTBubblingEventBlock?
+
+    // MARK: - Avatar Placeholder Properties
+
+    /// The participant's name for the avatar placeholder
+    @objc public var participantName: NSString? = nil {
+        didSet {
+            PictureInPictureLogger.log("RTCViewPip.participantName didSet: \(participantName as String? ?? "nil"), controller exists: \(pictureInPictureController != nil)")
+            pictureInPictureController?.participantName = participantName as String?
+        }
+    }
+
+    /// The URL string for the participant's profile image
+    @objc public var participantImageURL: NSString? = nil {
+        didSet {
+            PictureInPictureLogger.log("RTCViewPip.participantImageURL didSet: \(participantImageURL as String? ?? "nil"), controller exists: \(pictureInPictureController != nil)")
+            pictureInPictureController?.participantImageURL = participantImageURL as String?
+        }
+    }
+
+    // MARK: - Reconnection Properties
+
+    /// Whether the call is reconnecting - when true, shows reconnection view
+    @objc public var isReconnecting: Bool = false {
+        didSet {
+            pictureInPictureController?.isReconnecting = isReconnecting
+        }
+    }
+
+    // MARK: - Screen Sharing Properties
+
+    /// Whether screen sharing is active (used for content state tracking)
+    @objc public var isScreenSharing: Bool = false {
+        didSet {
+            pictureInPictureController?.isScreenSharing = isScreenSharing
+        }
+    }
+
+    // MARK: - Participant Overlay Properties
+
+    /// Whether the participant has audio enabled (shown in participant overlay)
+    @objc public var hasAudio: Bool = true {
+        didSet {
+            pictureInPictureController?.hasAudio = hasAudio
+        }
+    }
+
+    /// Whether the video track is paused (shown in participant overlay)
+    @objc public var isTrackPaused: Bool = false {
+        didSet {
+            pictureInPictureController?.isTrackPaused = isTrackPaused
+        }
+    }
+
+    /// Whether the participant is pinned (shown in participant overlay)
+    @objc public var isPinned: Bool = false {
+        didSet {
+            pictureInPictureController?.isPinned = isPinned
+        }
+    }
+
+    /// Whether the participant is currently speaking (shows border highlight)
+    @objc public var isSpeaking: Bool = false {
+        didSet {
+            pictureInPictureController?.isSpeaking = isSpeaking
+        }
+    }
+
+    /// The connection quality level (0: unknown, 1: poor, 2: good, 3: excellent)
+    @objc public var connectionQuality: Int = 0 {
+        didSet {
+            pictureInPictureController?.connectionQuality = connectionQuality
+        }
+    }
+
     @objc public var mirror: Bool = false {
         didSet {
             self.pictureInPictureController?.isMirrored = mirror
@@ -38,27 +112,36 @@ class RTCViewPip: UIView {
         didSet {
             // https://github.com/react-native-webrtc/react-native-webrtc/blob/8dfc9c394b4bf627c0214255466ebd3b160ca563/ios/RCTWebRTC/RTCVideoViewManager.m#L405-L418
             guard let streamURLString = streamURL as String? else {
-                NSLog("PiP - No streamURL set")
+                PictureInPictureLogger.log("No streamURL set, clearing track")
+                DispatchQueue.main.async {
+                    self.applyTrackStateToController(track: nil, isVideoEnabled: false)
+                }
                 return
             }
-            
+
             guard let stream = self.webRtcModule?.stream(forReactTag: streamURLString) else {
-                NSLog("PiP - No stream for streamURL: -\(streamURLString)")
+                PictureInPictureLogger.log("No stream for streamURL: -\(streamURLString), clearing track")
+                DispatchQueue.main.async {
+                    self.applyTrackStateToController(track: nil, isVideoEnabled: false)
+                }
                 return
             }
-            
+
             guard let videoTrack = stream.videoTracks.first else {
-                NSLog("PiP - No video track for streamURL: -\(streamURLString)")
+                PictureInPictureLogger.log("No video track for streamURL: -\(streamURLString), clearing track")
+                DispatchQueue.main.async {
+                    self.applyTrackStateToController(track: nil, isVideoEnabled: false)
+                }
                 return
             }
-            if (self.pictureInPictureController?.track == videoTrack) {
-                NSLog("PiP - Skipping video track for streamURL: -\(streamURLString)")
+            if isSameTrackInstance(self.pictureInPictureController?.track, videoTrack) {
+                PictureInPictureLogger.log("Skipping video track for streamURL: -\(streamURLString)")
                 return
             }
-            
+
             DispatchQueue.main.async {
-                NSLog("PiP - Setting video track for streamURL: -\(streamURLString) trackId: \(videoTrack.trackId)")
-                self.pictureInPictureController?.track = videoTrack
+                PictureInPictureLogger.log("Setting video track for streamURL: -\(streamURLString) trackId: \(videoTrack.trackId)")
+                self.applyTrackStateToController(track: videoTrack, isVideoEnabled: true)
             }
         }
     }
@@ -70,30 +153,40 @@ class RTCViewPip: UIView {
     
     @objc
     func onCallClosed() {
-        NSLog("PiP - pictureInPictureController cleanup called")
+        PictureInPictureLogger.log("pictureInPictureController cleanup called")
         self.pictureInPictureController?.cleanup()
         self.pictureInPictureController = nil
     }
     
     @objc
     func setPreferredContentSize(_ size: CGSize) {
-        NSLog("PiP - RTCViewPip setPreferredContentSize \(size)")
+        PictureInPictureLogger.log("RTCViewPip setPreferredContentSize \(size)")
         self.pictureInPictureController?.setPreferredContentSize(size)
     }
     
     override func didMoveToSuperview() {
         super.didMoveToSuperview()
         if self.superview == nil {
-            NSLog("PiP - RTCViewPip has been removed from its superview.")
+            PictureInPictureLogger.log("RTCViewPip has been removed from its superview.")
             NotificationCenter.default.removeObserver(self)
             DispatchQueue.main.async {
-                NSLog("PiP - onCallClosed called due to view detaching")
+                PictureInPictureLogger.log("onCallClosed called due to view detaching")
                 self.onCallClosed()
             }
         } else {
-            NSLog("PiP - RTCViewPip has been added to a superview.")
+            PictureInPictureLogger.log("RTCViewPip has been added to a superview.")
             setupNotificationObserver()
             DispatchQueue.main.async {
+                // Recreate controller if it was previously cleaned up
+                // This allows PiP to work again for subsequent calls
+                let wasNil = self.pictureInPictureController == nil
+                if wasNil {
+                    PictureInPictureLogger.log("Recreating pictureInPictureController for new session")
+                    self.pictureInPictureController = StreamPictureInPictureController()
+                    // Re-apply all current properties to the new controller
+                    // This is necessary because React Native may have set props while controller was nil
+                    self.applyCurrentPropertiesToController()
+                }
                 self.pictureInPictureController?.sourceView = self
                 self.pictureInPictureController?.isMirrored = self.mirror
                 // Set up PiP state change callback
@@ -103,20 +196,93 @@ class RTCViewPip: UIView {
                 if let reactTag = self.reactTag, let bridge = self.webRtcModule?.bridge {
                     if let manager = bridge.module(for: RTCViewPipManager.self) as? RTCViewPipManager,
                        let size = manager.getCachedSize(for: reactTag) {
-                        NSLog("PiP - Applying cached size \(size) for reactTag \(reactTag)")
+                        PictureInPictureLogger.log("Applying cached size \(size) for reactTag \(reactTag)")
                         self.setPreferredContentSize(size)
                     }
                 }
             }
         }
     }
+
+    /// Re-applies all current property values to the controller.
+    /// This is needed after controller recreation because didSet doesn't fire
+    /// when the property values haven't changed on the React Native side.
+    ///
+    /// NOTE: This reads from RTCViewPip's own properties (self.participantName, etc.)
+    /// which retain their values even after controller cleanup.
+    private func applyCurrentPropertiesToController() {
+        guard let controller = pictureInPictureController else {
+            PictureInPictureLogger.log("applyCurrentPropertiesToController: controller is nil, skipping")
+            return
+        }
+
+        PictureInPictureLogger.log("applyCurrentPropertiesToController STARTING:")
+        PictureInPictureLogger.log("  participantName: '\(participantName as String? ?? "nil")'")
+        PictureInPictureLogger.log("  participantImageURL: '\(participantImageURL as String? ?? "nil")'")
+        PictureInPictureLogger.log("  streamURL: '\(streamURL as String? ?? "nil")'")
+
+        let resolvedTrack: RTCVideoTrack?
+        let isVideoEnabled: Bool
+        if let streamURLString = streamURL as String?,
+           let stream = webRtcModule?.stream(forReactTag: streamURLString),
+           let videoTrack = stream.videoTracks.first {
+            PictureInPictureLogger.log("Re-applying track from streamURL: \(streamURLString), trackId: \(videoTrack.trackId)")
+            resolvedTrack = videoTrack
+            isVideoEnabled = true
+        } else {
+            // No stream URL or no track means video is disabled - show avatar
+            PictureInPictureLogger.log("No valid stream/track, setting isVideoEnabled=false for avatar")
+            resolvedTrack = nil
+            isVideoEnabled = false
+        }
+
+        // Keep PiP content transitions store-driven with one snapshot update.
+        controller.applyContentSnapshot(
+            track: resolvedTrack,
+            participantName: participantName as String?,
+            participantImageURL: participantImageURL as String?,
+            isVideoEnabled: isVideoEnabled,
+            isScreenSharing: isScreenSharing,
+            isReconnecting: isReconnecting
+        )
+
+        controller.hasAudio = hasAudio
+        controller.isTrackPaused = isTrackPaused
+        controller.isPinned = isPinned
+        controller.isSpeaking = isSpeaking
+        controller.connectionQuality = connectionQuality
+        PictureInPictureLogger.log("applyCurrentPropertiesToController COMPLETED")
+    }
+
+    /// Applies track/video availability without splitting a single change into multiple setters.
+    private func applyTrackStateToController(track: RTCVideoTrack?, isVideoEnabled: Bool) {
+        pictureInPictureController?.applyContentSnapshot(
+            track: track,
+            participantName: participantName as String?,
+            participantImageURL: participantImageURL as String?,
+            isVideoEnabled: isVideoEnabled,
+            isScreenSharing: isScreenSharing,
+            isReconnecting: isReconnecting
+        )
+    }
+
+    private func isSameTrackInstance(_ lhs: RTCVideoTrack?, _ rhs: RTCVideoTrack?) -> Bool {
+        switch (lhs, rhs) {
+        case (nil, nil):
+            return true
+        case let (lhsTrack?, rhsTrack?):
+            return lhsTrack === rhsTrack
+        default:
+            return false
+        }
+    }
     
     private func sendPiPChangeEvent(isActive: Bool) {
         guard let onPiPChange = onPiPChange else {
             return
         }
-        
-        NSLog("PiP - Sending PiP state change event: \(isActive)")
+
+        PictureInPictureLogger.log("Sending PiP state change event: \(isActive)")
         onPiPChange(["active": isActive])
     }
 }

package/ios/RTCViewPipManager.mm

@@ -13,6 +13,15 @@
 RCT_EXPORT_VIEW_PROPERTY(streamURL, NSString)
 RCT_EXPORT_VIEW_PROPERTY(mirror, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(onPiPChange, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(participantName, NSString)
+RCT_EXPORT_VIEW_PROPERTY(participantImageURL, NSString)
+RCT_EXPORT_VIEW_PROPERTY(isReconnecting, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(isScreenSharing, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(hasAudio, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(isTrackPaused, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(isPinned, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(isSpeaking, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(connectionQuality, NSInteger)
 RCT_EXTERN_METHOD(onCallClosed:(nonnull NSNumber*) reactTag)
 RCT_EXTERN_METHOD(setPreferredContentSize:(nonnull NSNumber *)reactTag width:(CGFloat)w height:(CGFloat)h);
 

package/ios/RTCViewPipManager.swift

@@ -32,7 +32,7 @@ class RTCViewPipManager: RCTViewManager {
                     pipView.onCallClosed()
                 }
             } else {
-                NSLog("PiP - onCallClosed cant be called, Invalid view returned from registry, expecting RTCViewPip")
+                PictureInPictureLogger.log("onCallClosed cant be called, Invalid view returned from registry, expecting RTCViewPip")
             }
         })
     }
@@ -51,7 +51,7 @@ class RTCViewPipManager: RCTViewManager {
             } else {
                 // If the view is not found, cache the size.
                 // this happens when this method is called before the view can attach react super view
-                NSLog("PiP - View not found for reactTag \(reactTag), caching size.")
+                PictureInPictureLogger.log("View not found for reactTag \(reactTag), caching size.")
                 self.cachedSizes[reactTag] = size
             }
         })
@@ -60,7 +60,7 @@ class RTCViewPipManager: RCTViewManager {
     func getCachedSize(for reactTag: NSNumber) -> CGSize? {
         let size = self.cachedSizes.removeValue(forKey: reactTag)
         if size != nil {
-            NSLog("PiP - Found and removed cached size for reactTag \(reactTag).")
+            PictureInPictureLogger.log("Found and removed cached size for reactTag \(reactTag).")
         }
         return size
     }

package/ios/StreamInCallManager.m

@@ -23,8 +23,6 @@ RCT_EXTERN_METHOD(setMicrophoneMute:(BOOL)enable)
 
 RCT_EXTERN_METHOD(logAudioState)
 
-RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getAudioStateLog)
-
 RCT_EXTERN_METHOD(muteAudioOutput)
 
 RCT_EXTERN_METHOD(unmuteAudioOutput)

package/ios/StreamInCallManager.swift

@@ -116,7 +116,7 @@ class StreamInCallManager: RCTEventEmitter {
                 }
             } else {
                 intendedCategory = .playAndRecord
-                intendedMode = .voiceChat
+                intendedMode = defaultAudioDevice == .speaker ? .videoChat : .voiceChat
                 
                 // XCode 16 and older don't expose .allowBluetoothHFP
                 // https://forums.swift.org/t/xcode-26-avaudiosession-categoryoptions-allowbluetooth-deprecated/80956
@@ -132,7 +132,6 @@ class StreamInCallManager: RCTEventEmitter {
             rtcConfig.category = intendedCategory.rawValue
             rtcConfig.mode = intendedMode.rawValue
             rtcConfig.categoryOptions = intendedOptions
-            // This ensures WebRTC's internal state stays consistent during interruptions/route changes
             RTCAudioSessionConfiguration.setWebRTC(rtcConfig)
             
             let session = RTCAudioSession.sharedInstance()
@@ -141,7 +140,7 @@ class StreamInCallManager: RCTEventEmitter {
                 session.unlockForConfiguration()
             }
             do {
-                try session.setConfiguration(rtcConfig)
+                try session.setCategory(intendedCategory, mode: intendedMode, options: intendedOptions)
                 if (wasRecording) {
                     try adm.setRecording(wasRecording)
                 }
@@ -267,11 +266,6 @@ class StreamInCallManager: RCTEventEmitter {
 
     @objc
     func logAudioState() {
-        log(getAudioStateLog())
-    }
-    
-    @objc(getAudioStateLog)
-    func getAudioStateLog() -> String {
         let session = AVAudioSession.sharedInstance()
         let adm = getAudioDeviceModule()
         
@@ -284,7 +278,7 @@ class StreamInCallManager: RCTEventEmitter {
 
         let rtcAVSession = rtcSession.session
         let logString = """
-        AVAudioSession State:
+        Audio State:
           Category: \(session.category.rawValue)
           Mode: \(session.mode.rawValue)
           Output Port: \(session.currentRoute.outputs.first?.portName ?? "N/A")
@@ -292,16 +286,10 @@ class StreamInCallManager: RCTEventEmitter {
           Category Options: \(session.categoryOptions)
           InputNumberOfChannels: \(session.inputNumberOfChannels)
           OutputNumberOfChannels: \(session.outputNumberOfChannels)
-
-        AudioDeviceModule State:
-          IsPlaying: \(adm.isPlaying)
-          IsRecording: \(adm.isRecording)
-          IsVoiceProcessingAGCEnabled: \(adm.isVoiceProcessingAGCEnabled)
-          IsVoiceProcessingBypassed: \(adm.isVoiceProcessingBypassed)
-          IsVoiceProcessingEnabled: \(adm.isVoiceProcessingEnabled)
-          IsStereoPlayoutEnabled: \(adm.isStereoPlayoutEnabled)
+          AdmIsPlaying: \(adm.isPlaying)
+          AdmIsRecording: \(adm.isRecording)
         
-        RTCAudioSession State:
+        RTC Audio State:
           Wrapped Category: \(rtcAVSession.category.rawValue)
           Wrapped Mode: \(rtcAVSession.mode.rawValue)
           Wrapped Output Port: \(rtcAVSession.currentRoute.outputs.first?.portName ?? "N/A")
@@ -312,7 +300,7 @@ class StreamInCallManager: RCTEventEmitter {
           IsActive: \(rtcSession.isActive)
           ActivationCount: \(rtcSession.activationCount)
         """
-        return logString
+        log(logString)
     }
 
     @objc(muteAudioOutput)

package/ios/StreamVideoReactNative.h

@@ -1,19 +1,16 @@
 #import <React/RCTEventEmitter.h>
 #import <React/RCTBridge.h>
-#import <PushKit/PushKit.h>
 
 @interface StreamVideoReactNative : RCTEventEmitter <RCTBridgeModule>
 
 - (void)screenShareEventReceived:(NSString *)event;
 
-+ (void)setup DEPRECATED_MSG_ATTRIBUTE("No need to use setup() anymore");
-
-+ (BOOL)hasAnyActiveCall;
++ (void)registerIncomingCall:(NSString *)cid uuid:(NSString *)uuid;
 
-+ (void)voipRegistration;
++ (void)setup DEPRECATED_MSG_ATTRIBUTE("No need to use setup() anymore");
 
-+ (void)didUpdatePushCredentials:(PKPushCredentials *)credentials forType:(NSString *)type;
++ (BOOL)shouldRejectCallWhenBusy;
 
-+ (void)didReceiveIncomingPush:(PKPushPayload *)payload forType:(NSString *)type completionHandler: (void (^_Nullable)(void)) completion;
++ (BOOL)hasAnyActiveCall;
 
 @end