fix(ui): fixes for PiP mode on iOS (#1101)

* iOS pip fixes

* changelog

* linter fix

Author: Brazol

packages/stream_video_flutter/CHANGELOG.md

@@ -19,6 +19,11 @@ In this release, we removed the dependency on `flutter_callkit_incoming`, which
 - `observeCallEndedCallKitEvent` → `observeCallEndedRingingEvent`
 - `CallKitEvent` (type) → `RingingEvent`
 
+🐞 Fixed
+* [iOS] Resolved an issue in Picture in Picture where video tracks might remain disabled after returning the app to the foreground.
+* [iOS] Addressed a problem where Picture in Picture was not exited properly if the call ended during PiP mode.
+* [iOS] Fixed a bug where quickly backgrounding the app right after ending a call could still activate PiP mode.
+
 ## 0.11.2
 
 🐞 Fixed

packages/stream_video_flutter/ios/stream_video_flutter/Sources/stream_video_flutter/PictureInPicture/StreamPictureInPictureController.swift

@@ -54,6 +54,8 @@ final class StreamPictureInPictureController: NSObject, AVPictureInPictureContro
     /// active track.
     private let trackStateAdapter: StreamPictureInPictureTrackStateAdapter = .init()
 
+    private var shouldCleanupAfterStop: Bool = false
+
     // MARK: - Lifecycle
 
     /// Initializes the controller and creates the content view
@@ -121,10 +123,31 @@ final class StreamPictureInPictureController: NSObject, AVPictureInPictureContro
     public func pictureInPictureControllerDidStopPictureInPicture(
         _ pictureInPictureController: AVPictureInPictureController
     ) {
+        if shouldCleanupAfterStop {
+            shouldCleanupAfterStop = false
+            track = nil
+            sourceView = nil
+        }
+
     }
 
     // MARK: - Public API
 
+    public func stopPictureInPictureAndCleanup() {
+        let isActive = pictureInPictureController?.isPictureInPictureActive == true
+
+        if isActive && !shouldCleanupAfterStop {
+            shouldCleanupAfterStop = true
+            pictureInPictureController?.stopPictureInPicture()
+        } else {
+            if track != nil || sourceView != nil {
+                shouldCleanupAfterStop = false
+                track = nil
+                sourceView = nil
+            }
+        }
+    }
+
     /// Updates participant information and refreshes overlay
     /// - Note: Only available on iOS 15.0+. Earlier versions will ignore this call.
     public func updateParticipant(

packages/stream_video_flutter/ios/stream_video_flutter/Sources/stream_video_flutter/StreamVideoFlutterPlugin.swift

@@ -175,8 +175,9 @@ class StreamPictureInPictureNativeView: NSObject, FlutterPlatformView {
             }
             result(nil)
         case "callEnded":
-            self.pictureInPictureController?.track = nil
-            self.pictureInPictureController?.sourceView = nil
+            DispatchQueue.main.async {
+                self.pictureInPictureController?.stopPictureInPictureAndCleanup()
+            }
             result(nil)
         default:
             result(FlutterMethodNotImplemented)

packages/stream_video_flutter/lib/src/call_screen/call_content/picture_in_picture/stream_picture_in_picture_ui_kit_view.dart

@@ -56,20 +56,21 @@ class _StreamPictureInPictureUiKitViewState
     extends State<StreamPictureInPictureUiKitView>
     with WidgetsBindingObserver {
   static const _idCallState = 2;
+  static const _idCallEnded = 3;
 
   static const MethodChannel _channel = MethodChannel(
     'stream_video_flutter_pip',
   );
 
   final Subscriptions _subscriptions = Subscriptions();
 
-  Future<void> _handleCallState(
-    CallState callState,
+  Future<void> _handleParticipantsChange(
+    List<CallParticipantState> callParticipants,
     bool includeLocalParticipantVideo,
   ) async {
     final participants = includeLocalParticipantVideo
-        ? callState.callParticipants
-        : callState.otherParticipants;
+        ? callParticipants
+        : callParticipants.where((element) => !element.isLocal).toList();
 
     final sorted = List<CallParticipantState>.from(participants);
     mergeSort(
@@ -125,21 +126,23 @@ class _StreamPictureInPictureUiKitViewState
         },
       );
     }
-
-    if (callState.status is CallStatusDisconnected) {
-      await _channel.invokeMethod(
-        'callEnded',
-      );
-    }
   }
 
   void _subscribeToCallEvents() {
+    if (widget.call.state.value.status is CallStatusDisconnected) {
+      return;
+    }
+
     _subscriptions.add(
       _idCallState,
       widget.call.state.listen(
-        (callState) {
-          _handleCallState(
-            callState,
+        (state) {
+          if (state.status is CallStatusDisconnected) {
+            return;
+          }
+
+          _handleParticipantsChange(
+            state.callParticipants,
             widget.configuration.includeLocalParticipantVideo &&
                 widget.call.state.value.iOSMultitaskingCameraAccessEnabled,
           );
@@ -152,6 +155,19 @@ class _StreamPictureInPictureUiKitViewState
   void initState() {
     WidgetsBinding.instance.addObserver(this);
 
+    _subscriptions.add(
+      _idCallEnded,
+      widget.call.state.listen(
+        (state) async {
+          if (state.status is CallStatusDisconnected) {
+            await _channel.invokeMethod(
+              'callEnded',
+            );
+          }
+        },
+      ),
+    );
+
     super.initState();
   }
 
@@ -161,16 +177,59 @@ class _StreamPictureInPictureUiKitViewState
 
     switch (state) {
       case AppLifecycleState.resumed:
-        _subscriptions.cancelAll();
+        _subscriptions.cancel(_idCallState);
+        _toggleSubscribedTracks(true);
         break;
       case AppLifecycleState.paused:
+        _toggleSubscribedTracks(false);
         _subscribeToCallEvents();
+
+        // Check status with a small delay to catch the race condition where
+        // the call disconnects at nearly the same time as backgrounding
+        Future.delayed(const Duration(milliseconds: 100), () {
+          if (!mounted) return;
+          if (widget.call.state.value.status is CallStatusDisconnected) {
+            try {
+              _channel.invokeMethod('callEnded');
+            } catch (e) {
+              // Silent catch
+            }
+          }
+        });
         break;
       default:
         break;
     }
   }
 
+  // When app goes to background disable video tracks of all participants except
+  // the one shown in PiP to save bandwidth and resources.
+  // Re-enable them when app comes back to foreground.
+  void _toggleSubscribedTracks(bool enable) {
+    final participants = widget.call.state.value.callParticipants;
+
+    for (final participant in participants.where(
+      (p) => p.isVideoEnabled,
+    )) {
+      if (!enable && participant.isSpeaking) {
+        // Do not disable video track of speaking participant
+        continue;
+      }
+
+      final videoTrackState = participant.publishedTracks[SfuTrackType.video];
+      if ((videoTrackState is RemoteTrackState && videoTrackState.subscribed) ||
+          participant.isLocal) {
+        final track = widget.call.getTrack(
+          participant.trackIdPrefix,
+          SfuTrackType.video,
+        );
+        if (track != null) {
+          track.mediaTrack.enabled = enable;
+        }
+      }
+    }
+  }
+
   @override
   void dispose() {
     WidgetsBinding.instance.removeObserver(this);