[video_player] Add Picture-in-Picture support for iOS

Adds PiP support across three packages:

## video_player_platform_interface (6.6.0 → 6.7.0)
- Add enablePictureInPicture, disablePictureInPicture, startPictureInPicture,
  stopPictureInPicture, isPictureInPictureSupported, isPictureInPictureActive
- Add pipStarted, pipStopped, pipRestoreUserInterface event types

## video_player_avfoundation (2.9.3 → 2.10.0)
- Integrate AVPictureInPictureController with AVPlayerLayer
- Support both texture-based and platform view players
- Implement PiP delegate callbacks (start/stop/restore UI)
- macOS returns stub implementations (PiP not supported)
- Requires iOS 14.2+

## video_player (2.11.0 → 2.12.0)
- Add isPictureInPictureActive field to VideoPlayerValue
- Add PiP methods to VideoPlayerController
- Handle PiP events in the event listener

Fixes flutter/flutter#60048

Author: akaboshinit

packages/video_player/video_player/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.12.0
+
+* Adds Picture-in-Picture (PiP) support for iOS.
+* Adds `isPictureInPictureActive` field to `VideoPlayerValue`.
+* Adds `enablePictureInPicture()`, `disablePictureInPicture()`, `startPictureInPicture()`, `stopPictureInPicture()`, `isPictureInPictureSupported()`, and `isPictureInPictureActive()` methods to `VideoPlayerController`.
+
 ## 2.11.0
 
 * Adds `getAudioTracks()` and `selectAudioTrack()` methods to retrieve and select available audio tracks.

packages/video_player/video_player/lib/video_player.dart

@@ -172,6 +172,7 @@ class VideoPlayerValue {
     this.rotationCorrection = 0,
     this.errorDescription,
     this.isCompleted = false,
+    this.isPictureInPictureActive = false,
   });
 
   /// Returns an instance for a video that hasn't been loaded.
@@ -238,6 +239,9 @@ class VideoPlayerValue {
   /// Does not update if video is looping.
   final bool isCompleted;
 
+  /// Whether Picture-in-Picture is currently active.
+  final bool isPictureInPictureActive;
+
   /// The [size] of the currently loaded video.
   final Size size;
 
@@ -286,6 +290,7 @@ class VideoPlayerValue {
     int? rotationCorrection,
     String? errorDescription = _defaultErrorDescription,
     bool? isCompleted,
+    bool? isPictureInPictureActive,
   }) {
     return VideoPlayerValue(
       duration: duration ?? this.duration,
@@ -305,6 +310,8 @@ class VideoPlayerValue {
           ? errorDescription
           : this.errorDescription,
       isCompleted: isCompleted ?? this.isCompleted,
+      isPictureInPictureActive:
+          isPictureInPictureActive ?? this.isPictureInPictureActive,
     );
   }
 
@@ -324,7 +331,8 @@ class VideoPlayerValue {
         'volume: $volume, '
         'playbackSpeed: $playbackSpeed, '
         'errorDescription: $errorDescription, '
-        'isCompleted: $isCompleted),';
+        'isCompleted: $isCompleted, '
+        'isPictureInPictureActive: $isPictureInPictureActive),';
   }
 
   @override
@@ -346,7 +354,8 @@ class VideoPlayerValue {
           size == other.size &&
           rotationCorrection == other.rotationCorrection &&
           isInitialized == other.isInitialized &&
-          isCompleted == other.isCompleted;
+          isCompleted == other.isCompleted &&
+          isPictureInPictureActive == other.isPictureInPictureActive;
 
   @override
   int get hashCode => Object.hash(
@@ -365,6 +374,7 @@ class VideoPlayerValue {
     rotationCorrection,
     isInitialized,
     isCompleted,
+    isPictureInPictureActive,
   );
 }
 
@@ -646,6 +656,12 @@ class VideoPlayerController extends ValueNotifier<VideoPlayerValue> {
           } else {
             value = value.copyWith(isPlaying: event.isPlaying);
           }
+        case platform_interface.VideoEventType.pipStarted:
+          value = value.copyWith(isPictureInPictureActive: true);
+        case platform_interface.VideoEventType.pipStopped:
+          value = value.copyWith(isPictureInPictureActive: false);
+        case platform_interface.VideoEventType.pipRestoreUserInterface:
+          break;
         case platform_interface.VideoEventType.unknown:
           break;
       }
@@ -988,6 +1004,71 @@ class VideoPlayerController extends ValueNotifier<VideoPlayerValue> {
     return _videoPlayerPlatform.isAudioTrackSupportAvailable();
   }
 
+  /// Enables Picture-in-Picture for this player.
+  ///
+  /// This must be called before [startPictureInPicture] to prepare the player
+  /// for PiP mode. On platforms that don't support PiP, this may be a no-op.
+  ///
+  /// Throws a [StateError] if the controller is disposed or not initialized.
+  Future<void> enablePictureInPicture() async {
+    if (_isDisposedOrNotInitialized) {
+      throw StateError('VideoPlayerController is disposed or not initialized');
+    }
+    await _videoPlayerPlatform.enablePictureInPicture(_playerId);
+  }
+
+  /// Disables Picture-in-Picture for this player.
+  ///
+  /// Throws a [StateError] if the controller is disposed or not initialized.
+  Future<void> disablePictureInPicture() async {
+    if (_isDisposedOrNotInitialized) {
+      throw StateError('VideoPlayerController is disposed or not initialized');
+    }
+    await _videoPlayerPlatform.disablePictureInPicture(_playerId);
+  }
+
+  /// Starts Picture-in-Picture mode for this player.
+  ///
+  /// [enablePictureInPicture] must be called before this method.
+  ///
+  /// Throws a [StateError] if the controller is disposed or not initialized.
+  Future<void> startPictureInPicture() async {
+    if (_isDisposedOrNotInitialized) {
+      throw StateError('VideoPlayerController is disposed or not initialized');
+    }
+    await _videoPlayerPlatform.startPictureInPicture(_playerId);
+  }
+
+  /// Stops Picture-in-Picture mode for this player.
+  ///
+  /// Throws a [StateError] if the controller is disposed or not initialized.
+  Future<void> stopPictureInPicture() async {
+    if (_isDisposedOrNotInitialized) {
+      throw StateError('VideoPlayerController is disposed or not initialized');
+    }
+    await _videoPlayerPlatform.stopPictureInPicture(_playerId);
+  }
+
+  /// Returns whether Picture-in-Picture is supported on this device.
+  ///
+  /// Throws a [StateError] if the controller is disposed or not initialized.
+  Future<bool> isPictureInPictureSupported() async {
+    if (_isDisposedOrNotInitialized) {
+      throw StateError('VideoPlayerController is disposed or not initialized');
+    }
+    return _videoPlayerPlatform.isPictureInPictureSupported(_playerId);
+  }
+
+  /// Returns whether Picture-in-Picture is currently active for this player.
+  ///
+  /// Throws a [StateError] if the controller is disposed or not initialized.
+  Future<bool> isPictureInPictureActive() async {
+    if (_isDisposedOrNotInitialized) {
+      throw StateError('VideoPlayerController is disposed or not initialized');
+    }
+    return _videoPlayerPlatform.isPictureInPictureActive(_playerId);
+  }
+
   bool get _isDisposedOrNotInitialized => _isDisposed || !value.isInitialized;
 }
 

packages/video_player/video_player/pubspec.yaml

@@ -3,7 +3,7 @@ description: Flutter plugin for displaying inline video with other Flutter
   widgets on Android, iOS, macOS and web.
 repository: https://github.com/flutter/packages/tree/main/packages/video_player/video_player
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+video_player%22
-version: 2.11.0
+version: 2.12.0
 
 environment:
   sdk: ^3.10.0
@@ -26,8 +26,8 @@ dependencies:
     sdk: flutter
   html: ^0.15.0
   video_player_android: ^2.9.1
-  video_player_avfoundation: ^2.9.0
-  video_player_platform_interface: ^6.6.0
+  video_player_avfoundation: ^2.10.0
+  video_player_platform_interface: ^6.7.0
   video_player_web: ^2.1.0
 
 dev_dependencies:

packages/video_player/video_player/test/video_player_test.dart

@@ -130,6 +130,24 @@ class FakeController extends ValueNotifier<VideoPlayerValue>
     return true;
   }
 
+  @override
+  Future<void> enablePictureInPicture() async {}
+
+  @override
+  Future<void> disablePictureInPicture() async {}
+
+  @override
+  Future<void> startPictureInPicture() async {}
+
+  @override
+  Future<void> stopPictureInPicture() async {}
+
+  @override
+  Future<bool> isPictureInPictureSupported() async => true;
+
+  @override
+  Future<bool> isPictureInPictureActive() async => false;
+
   String? selectedAudioTrackId;
 }
 
@@ -1050,6 +1068,128 @@ void main() {
       });
     });
 
+    group('Picture-in-Picture', () {
+      test('enablePictureInPicture calls platform', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        await controller.initialize();
+        await controller.enablePictureInPicture();
+
+        expect(fakeVideoPlayerPlatform.calls.last, 'enablePictureInPicture');
+      });
+
+      test('disablePictureInPicture calls platform', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        await controller.initialize();
+        await controller.disablePictureInPicture();
+
+        expect(fakeVideoPlayerPlatform.calls.last, 'disablePictureInPicture');
+      });
+
+      test('startPictureInPicture calls platform', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        await controller.initialize();
+        await controller.startPictureInPicture();
+
+        expect(fakeVideoPlayerPlatform.calls.last, 'startPictureInPicture');
+      });
+
+      test('stopPictureInPicture calls platform', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        await controller.initialize();
+        await controller.stopPictureInPicture();
+
+        expect(fakeVideoPlayerPlatform.calls.last, 'stopPictureInPicture');
+      });
+
+      test('isPictureInPictureSupported returns result', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        await controller.initialize();
+        final bool result = await controller.isPictureInPictureSupported();
+
+        expect(result, true);
+        expect(
+          fakeVideoPlayerPlatform.calls.last,
+          'isPictureInPictureSupported',
+        );
+      });
+
+      test('isPictureInPictureActive returns result', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        await controller.initialize();
+        final bool result = await controller.isPictureInPictureActive();
+
+        expect(result, false);
+        expect(fakeVideoPlayerPlatform.calls.last, 'isPictureInPictureActive');
+      });
+
+      test('PiP methods before initialization throw', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        expect(
+          () => controller.enablePictureInPicture(),
+          throwsA(isA<StateError>()),
+        );
+        expect(
+          () => controller.startPictureInPicture(),
+          throwsA(isA<StateError>()),
+        );
+        expect(
+          () => controller.stopPictureInPicture(),
+          throwsA(isA<StateError>()),
+        );
+      });
+
+      test('pipStarted event updates VideoPlayerValue', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        await controller.initialize();
+
+        expect(controller.value.isPictureInPictureActive, false);
+
+        fakeVideoPlayerPlatform.streams[controller.playerId]!.add(
+          VideoEvent(eventType: VideoEventType.pipStarted),
+        );
+        await Future<void>.delayed(Duration.zero);
+
+        expect(controller.value.isPictureInPictureActive, true);
+      });
+
+      test('pipStopped event updates VideoPlayerValue', () async {
+        final controller = VideoPlayerController.networkUrl(_localhostUri);
+        addTearDown(controller.dispose);
+
+        await controller.initialize();
+
+        // Simulate PiP started first.
+        fakeVideoPlayerPlatform.streams[controller.playerId]!.add(
+          VideoEvent(eventType: VideoEventType.pipStarted),
+        );
+        await Future<void>.delayed(Duration.zero);
+        expect(controller.value.isPictureInPictureActive, true);
+
+        // Now stop PiP.
+        fakeVideoPlayerPlatform.streams[controller.playerId]!.add(
+          VideoEvent(eventType: VideoEventType.pipStopped),
+        );
+        await Future<void>.delayed(Duration.zero);
+        expect(controller.value.isPictureInPictureActive, false);
+      });
+    });
+
     group('caption', () {
       test('works when position updates', () async {
         final controller = VideoPlayerController.networkUrl(
@@ -1476,7 +1616,8 @@ void main() {
         'volume: 0.5, '
         'playbackSpeed: 1.5, '
         'errorDescription: null, '
-        'isCompleted: false),',
+        'isCompleted: false, '
+        'isPictureInPictureActive: false),',
       );
     });
 
@@ -1904,4 +2045,36 @@ class FakeVideoPlayerPlatform extends VideoPlayerPlatform {
   }
 
   final Map<int, String> selectedAudioTrackIds = <int, String>{};
+
+  @override
+  Future<void> enablePictureInPicture(int playerId) async {
+    calls.add('enablePictureInPicture');
+  }
+
+  @override
+  Future<void> disablePictureInPicture(int playerId) async {
+    calls.add('disablePictureInPicture');
+  }
+
+  @override
+  Future<void> startPictureInPicture(int playerId) async {
+    calls.add('startPictureInPicture');
+  }
+
+  @override
+  Future<void> stopPictureInPicture(int playerId) async {
+    calls.add('stopPictureInPicture');
+  }
+
+  @override
+  Future<bool> isPictureInPictureSupported(int playerId) async {
+    calls.add('isPictureInPictureSupported');
+    return true;
+  }
+
+  @override
+  Future<bool> isPictureInPictureActive(int playerId) async {
+    calls.add('isPictureInPictureActive');
+    return false;
+  }
 }

packages/video_player/video_player_avfoundation/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.10.0
+
+* Adds Picture-in-Picture (PiP) support for iOS.
+* Implements `enablePictureInPicture()`, `disablePictureInPicture()`, `startPictureInPicture()`, `stopPictureInPicture()`, `isPictureInPictureSupported()`, and `isPictureInPictureActive()` methods.
+
 ## 2.9.3
 
 * Fixes a regression where HTTP headers were ignored.