[video_player] Move iOS/macOS to per-player-instance Pigeon APIs (flutter#9529)

Rather than having a single API to talk directly to the plugin, and having most of the methods in that API just do a map lookup and dispatch to a player instance, which was necessary when Pigeon didn't support instantiating multiple instances of an API, have each player instance set up an API instance that the Dart code can talk to directly. This follows the pattern used by plugins that migrated to Pigeon more recently (e.g., `google_maps_flutter` has a very similar pattern), reduces boilerplate native code, and moves closer to what an FFI-based implementation would look like if we go that route in the future.

Since the Dart unit tests needed to be significantly reworked anyway, this also moves to the pattern we are using in newer plugin code, where we use `mockito` to mock the Pigeon API surface. The "call log" approach it replaces dates back to pre-Pigeon, when only way to test that the right platform calls were made was to intercept and track method channel calls at the framework level.

Also updates to the latest version of Pigeon.

## Pre-Review Checklist

[^1]: Regular contributors who have demonstrated familiarity with the repository guidelines only need to comment if the PR is not auto-exempted by repo tooling.

Author: stuartmorgan-g

packages/video_player/video_player_avfoundation/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.7.3
+
+* Restructures the communication between Dart and native code.
+
 ## 2.7.2
 
 * Uses `CADisplayLink` on macOS 14.0+.

packages/video_player/video_player_avfoundation/darwin/RunnerTests/VideoPlayerTests.m

@@ -28,32 +28,28 @@ @interface FVPTextureBasedVideoPlayer ()
 // (e.g., after a seek while paused). If YES, the display link should continue to run until the next
 // frame is successfully provided.
 @property(nonatomic, assign) BOOL waitingForFrame;
-@property(nonatomic, copy) void (^onDisposed)(int64_t);
 @end
 
 @implementation FVPTextureBasedVideoPlayer
 - (instancetype)initWithAsset:(NSString *)asset
                  frameUpdater:(FVPFrameUpdater *)frameUpdater
                   displayLink:(NSObject<FVPDisplayLink> *)displayLink
                     avFactory:(id<FVPAVFactory>)avFactory
-                 viewProvider:(NSObject<FVPViewProvider> *)viewProvider
-                   onDisposed:(void (^)(int64_t))onDisposed {
+                 viewProvider:(NSObject<FVPViewProvider> *)viewProvider {
   return [self initWithURL:[NSURL fileURLWithPath:[FVPVideoPlayer absolutePathForAssetName:asset]]
               frameUpdater:frameUpdater
                displayLink:displayLink
                httpHeaders:@{}
                  avFactory:avFactory
-              viewProvider:viewProvider
-                onDisposed:onDisposed];
+              viewProvider:viewProvider];
 }
 
 - (instancetype)initWithURL:(NSURL *)url
                frameUpdater:(FVPFrameUpdater *)frameUpdater
                 displayLink:(NSObject<FVPDisplayLink> *)displayLink
                 httpHeaders:(nonnull NSDictionary<NSString *, NSString *> *)headers
                   avFactory:(id<FVPAVFactory>)avFactory
-               viewProvider:(NSObject<FVPViewProvider> *)viewProvider
-                 onDisposed:(void (^)(int64_t))onDisposed {
+               viewProvider:(NSObject<FVPViewProvider> *)viewProvider {
   NSDictionary<NSString *, id> *options = nil;
   if ([headers count] != 0) {
     options = @{@"AVURLAssetHTTPHeaderFieldsKey" : headers};
@@ -64,24 +60,21 @@ - (instancetype)initWithURL:(NSURL *)url
                      frameUpdater:frameUpdater
                       displayLink:displayLink
                         avFactory:avFactory
-                     viewProvider:viewProvider
-                       onDisposed:onDisposed];
+                     viewProvider:viewProvider];
 }
 
 - (instancetype)initWithPlayerItem:(AVPlayerItem *)item
                       frameUpdater:(FVPFrameUpdater *)frameUpdater
                        displayLink:(NSObject<FVPDisplayLink> *)displayLink
                          avFactory:(id<FVPAVFactory>)avFactory
-                      viewProvider:(NSObject<FVPViewProvider> *)viewProvider
-                        onDisposed:(void (^)(int64_t))onDisposed {
+                      viewProvider:(NSObject<FVPViewProvider> *)viewProvider {
   self = [super initWithPlayerItem:item avFactory:avFactory viewProvider:viewProvider];
 
   if (self) {
     _frameUpdater = frameUpdater;
     _displayLink = displayLink;
     _frameUpdater.displayLink = _displayLink;
     _selfRefresh = true;
-    _onDisposed = [onDisposed copy];
 
     // This is to fix 2 bugs: 1. blank video for encrypted video streams on iOS 16
     // (https://github.com/flutter/flutter/issues/111457) and 2. swapped width and height for some
@@ -117,10 +110,10 @@ - (void)updatePlayingState {
   _displayLink.running = self.isPlaying || self.waitingForFrame;
 }
 
-- (void)seekTo:(int64_t)location completionHandler:(void (^)(BOOL))completionHandler {
+- (void)seekTo:(NSInteger)position completion:(void (^)(FlutterError *_Nullable))completion {
   CMTime previousCMTime = self.player.currentTime;
-  [super seekTo:location
-      completionHandler:^(BOOL completed) {
+  [super seekTo:position
+      completion:^(FlutterError *error) {
         if (CMTimeCompare(self.player.currentTime, previousCMTime) != 0) {
           // Ensure that a frame is drawn once available, even if currently paused. In theory a
           // race is possible here where the new frame has already drawn by the time this code
@@ -131,8 +124,8 @@ - (void)seekTo:(int64_t)location completionHandler:(void (^)(BOOL))completionHan
           [self expectFrame];
         }
 
-        if (completionHandler) {
-          completionHandler(completed);
+        if (completion) {
+          completion(error);
         }
       }];
 }
@@ -153,12 +146,6 @@ - (void)disposeSansEventChannel {
   _displayLink = nil;
 }
 
-- (void)dispose {
-  [super dispose];
-
-  _onDisposed(self.frameUpdater.textureIdentifier);
-}
-
 #pragma mark - FlutterTexture
 
 - (CVPixelBufferRef)copyPixelBuffer {

packages/video_player/video_player_avfoundation/darwin/video_player_avfoundation/Sources/video_player_avfoundation/FVPTextureBasedVideoPlayer.m

@@ -4,7 +4,6 @@
 
 #import "./include/video_player_avfoundation/FVPVideoPlayer.h"
 #import "./include/video_player_avfoundation/FVPVideoPlayer_Internal.h"
-#import "./include/video_player_avfoundation/FVPVideoPlayer_Test.h"
 
 #import <GLKit/GLKit.h>
 
@@ -104,6 +103,25 @@ - (void)dealloc {
   }
 }
 
+/// This method allows you to dispose without touching the event channel. This
+/// is useful for the case where the Engine is in the process of deconstruction
+/// so the channel is going to die or is already dead.
+- (void)disposeSansEventChannel {
+  _disposed = YES;
+  [self removeKeyValueObservers];
+
+  [self.player replaceCurrentItemWithPlayerItem:nil];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)dispose {
+  [self disposeSansEventChannel];
+  if (_onDisposed) {
+    _onDisposed();
+  }
+  [_eventChannel setStreamHandler:nil];
+}
+
 + (NSString *)absolutePathForAssetName:(NSString *)assetName {
   NSString *path = [[NSBundle mainBundle] pathForResource:assetName ofType:nil];
 #if TARGET_OS_OSX
@@ -405,57 +423,56 @@ - (void)setupEventSinkIfReadyToPlay {
   }
 }
 
-- (void)play {
+#pragma mark - FVPVideoPlayerInstanceApi
+
+- (void)playWithError:(FlutterError *_Nullable *_Nonnull)error {
   _isPlaying = YES;
   [self updatePlayingState];
 }
 
-- (void)pause {
+- (void)pauseWithError:(FlutterError *_Nullable *_Nonnull)error {
   _isPlaying = NO;
   [self updatePlayingState];
 }
 
-- (int64_t)position {
-  return FVPCMTimeToMillis([_player currentTime]);
-}
-
-- (int64_t)duration {
-  // Note: https://openradar.appspot.com/radar?id=4968600712511488
-  // `[AVPlayerItem duration]` can be `kCMTimeIndefinite`,
-  // use `[[AVPlayerItem asset] duration]` instead.
-  return FVPCMTimeToMillis([[[_player currentItem] asset] duration]);
+- (nullable NSNumber *)position:(FlutterError *_Nullable *_Nonnull)error {
+  return @(FVPCMTimeToMillis([_player currentTime]));
 }
 
-- (void)seekTo:(int64_t)location completionHandler:(void (^)(BOOL))completionHandler {
-  CMTime targetCMTime = CMTimeMake(location, 1000);
+- (void)seekTo:(NSInteger)position completion:(void (^)(FlutterError *_Nullable))completion {
+  CMTime targetCMTime = CMTimeMake(position, 1000);
   CMTimeValue duration = _player.currentItem.asset.duration.value;
   // Without adding tolerance when seeking to duration,
   // seekToTime will never complete, and this call will hang.
   // see issue https://github.com/flutter/flutter/issues/124475.
-  CMTime tolerance = location == duration ? CMTimeMake(1, 1000) : kCMTimeZero;
+  CMTime tolerance = position == duration ? CMTimeMake(1, 1000) : kCMTimeZero;
   [_player seekToTime:targetCMTime
         toleranceBefore:tolerance
          toleranceAfter:tolerance
       completionHandler:^(BOOL completed) {
-        if (completionHandler) {
-          completionHandler(completed);
+        if (completion) {
+          dispatch_async(dispatch_get_main_queue(), ^{
+            completion(nil);
+          });
         }
       }];
 }
 
-- (void)setIsLooping:(BOOL)isLooping {
-  _isLooping = isLooping;
+- (void)setLooping:(BOOL)looping error:(FlutterError *_Nullable *_Nonnull)error {
+  _isLooping = looping;
 }
 
-- (void)setVolume:(double)volume {
+- (void)setVolume:(double)volume error:(FlutterError *_Nullable *_Nonnull)error {
   _player.volume = (float)((volume < 0.0) ? 0.0 : ((volume > 1.0) ? 1.0 : volume));
 }
 
-- (void)setPlaybackSpeed:(double)speed {
+- (void)setPlaybackSpeed:(double)speed error:(FlutterError *_Nullable *_Nonnull)error {
   _targetPlaybackSpeed = @(speed);
   [self updatePlayingState];
 }
 
+#pragma mark - FlutterStreamHandler
+
 - (FlutterError *_Nullable)onCancelWithArguments:(id _Nullable)arguments {
   _eventSink = nil;
   return nil;
@@ -480,20 +497,13 @@ - (FlutterError *_Nullable)onListenWithArguments:(id _Nullable)arguments
   return nil;
 }
 
-/// This method allows you to dispose without touching the event channel. This
-/// is useful for the case where the Engine is in the process of deconstruction
-/// so the channel is going to die or is already dead.
-- (void)disposeSansEventChannel {
-  _disposed = YES;
-  [self removeKeyValueObservers];
-
-  [self.player replaceCurrentItemWithPlayerItem:nil];
-  [[NSNotificationCenter defaultCenter] removeObserver:self];
-}
+#pragma mark - Private
 
-- (void)dispose {
-  [self disposeSansEventChannel];
-  [_eventChannel setStreamHandler:nil];
+- (int64_t)duration {
+  // Note: https://openradar.appspot.com/radar?id=4968600712511488
+  // `[AVPlayerItem duration]` can be `kCMTimeIndefinite`,
+  // use `[[AVPlayerItem asset] duration]` instead.
+  return FVPCMTimeToMillis([[[_player currentItem] asset] duration]);
 }
 
 /// Removes all key-value observers set up for the player.

packages/video_player/video_player_avfoundation/darwin/video_player_avfoundation/Sources/video_player_avfoundation/FVPVideoPlayer.m

@@ -115,18 +115,32 @@ - (int64_t)onPlayerSetup:(FVPVideoPlayer *)player {
 
   int64_t playerIdentifier;
   if (textureBasedPlayer) {
-    playerIdentifier = [self.registry registerTexture:(FVPTextureBasedVideoPlayer *)player];
+    playerIdentifier = [self.registry registerTexture:textureBasedPlayer];
     [textureBasedPlayer setTextureIdentifier:playerIdentifier];
   } else {
     playerIdentifier = self.nextNonTexturePlayerIdentifier--;
   }
 
+  NSObject<FlutterBinaryMessenger> *messenger = self.messenger;
+  NSString *channelSuffix = [NSString stringWithFormat:@"%lld", playerIdentifier];
+  // Set up the player-specific API handler, and its onDispose unregistration.
+  SetUpFVPVideoPlayerInstanceApiWithSuffix(messenger, player, channelSuffix);
+  __weak typeof(self) weakSelf = self;
+  BOOL isTextureBased = textureBasedPlayer != nil;
+  player.onDisposed = ^() {
+    SetUpFVPVideoPlayerInstanceApiWithSuffix(messenger, nil, channelSuffix);
+    if (isTextureBased) {
+      [weakSelf.registry unregisterTexture:playerIdentifier];
+    }
+  };
+  // Set up the event channel.
   FlutterEventChannel *eventChannel = [FlutterEventChannel
-      eventChannelWithName:[NSString stringWithFormat:@"flutter.io/videoPlayer/videoEvents%lld",
-                                                      playerIdentifier]
-           binaryMessenger:_messenger];
+      eventChannelWithName:[NSString stringWithFormat:@"flutter.io/videoPlayer/videoEvents%@",
+                                                      channelSuffix]
+           binaryMessenger:messenger];
   [eventChannel setStreamHandler:player];
   player.eventChannel = eventChannel;
+
   self.playersByIdentifier[@(playerIdentifier)] = player;
 
   // Ensure that the first frame is drawn once available, even if the video isn't played, since
@@ -211,27 +225,20 @@ - (nullable FVPTextureBasedVideoPlayer *)texturePlayerWithOptions:
                                                  [frameUpdater displayLinkFired];
                                                }];
 
-  __weak typeof(self) weakSelf = self;
-  void (^onDisposed)(int64_t) = ^(int64_t textureIdentifier) {
-    [weakSelf.registry unregisterTexture:textureIdentifier];
-  };
-
   if (options.asset) {
     NSString *assetPath = [self assetPathFromCreationOptions:options];
     return [[FVPTextureBasedVideoPlayer alloc] initWithAsset:assetPath
                                                 frameUpdater:frameUpdater
                                                  displayLink:displayLink
                                                    avFactory:self.avFactory
-                                                viewProvider:self.viewProvider
-                                                  onDisposed:onDisposed];
+                                                viewProvider:self.viewProvider];
   } else if (options.uri) {
     return [[FVPTextureBasedVideoPlayer alloc] initWithURL:[NSURL URLWithString:options.uri]
                                               frameUpdater:frameUpdater
                                                displayLink:displayLink
                                                httpHeaders:options.httpHeaders
                                                  avFactory:self.avFactory
-                                              viewProvider:self.viewProvider
-                                                onDisposed:onDisposed];
+                                              viewProvider:self.viewProvider];
   }
 
   return nil;
@@ -271,54 +278,6 @@ - (void)disposePlayer:(NSInteger)playerIdentifier error:(FlutterError **)error {
   [player dispose];
 }
 
-- (void)setLooping:(BOOL)isLooping
-         forPlayer:(NSInteger)playerIdentifier
-             error:(FlutterError **)error {
-  FVPVideoPlayer *player = self.playersByIdentifier[@(playerIdentifier)];
-  player.isLooping = isLooping;
-}
-
-- (void)setVolume:(double)volume
-        forPlayer:(NSInteger)playerIdentifier
-            error:(FlutterError **)error {
-  FVPVideoPlayer *player = self.playersByIdentifier[@(playerIdentifier)];
-  [player setVolume:volume];
-}
-
-- (void)setPlaybackSpeed:(double)speed
-               forPlayer:(NSInteger)playerIdentifier
-                   error:(FlutterError **)error {
-  FVPVideoPlayer *player = self.playersByIdentifier[@(playerIdentifier)];
-  [player setPlaybackSpeed:speed];
-}
-
-- (void)playPlayer:(NSInteger)playerIdentifier error:(FlutterError **)error {
-  FVPVideoPlayer *player = self.playersByIdentifier[@(playerIdentifier)];
-  [player play];
-}
-
-- (nullable NSNumber *)positionForPlayer:(NSInteger)playerIdentifier error:(FlutterError **)error {
-  FVPVideoPlayer *player = self.playersByIdentifier[@(playerIdentifier)];
-  return @([player position]);
-}
-
-- (void)seekTo:(NSInteger)position
-     forPlayer:(NSInteger)playerIdentifier
-    completion:(nonnull void (^)(FlutterError *_Nullable))completion {
-  FVPVideoPlayer *player = self.playersByIdentifier[@(playerIdentifier)];
-  [player seekTo:position
-      completionHandler:^(BOOL finished) {
-        dispatch_async(dispatch_get_main_queue(), ^{
-          completion(nil);
-        });
-      }];
-}
-
-- (void)pausePlayer:(NSInteger)playerIdentifier error:(FlutterError **)error {
-  FVPVideoPlayer *player = self.playersByIdentifier[@(playerIdentifier)];
-  [player pause];
-}
-
 - (void)setMixWithOthers:(BOOL)mixWithOthers
                    error:(FlutterError *_Nullable __autoreleasing *)error {
 #if TARGET_OS_OSX

packages/video_player/video_player_avfoundation/darwin/video_player_avfoundation/Sources/video_player_avfoundation/FVPVideoPlayerPlugin.m

@@ -21,17 +21,15 @@ NS_ASSUME_NONNULL_BEGIN
                 displayLink:(NSObject<FVPDisplayLink> *)displayLink
                 httpHeaders:(nonnull NSDictionary<NSString *, NSString *> *)headers
                   avFactory:(id<FVPAVFactory>)avFactory
-               viewProvider:(NSObject<FVPViewProvider> *)viewProvider
-                 onDisposed:(void (^)(int64_t))onDisposed;
+               viewProvider:(NSObject<FVPViewProvider> *)viewProvider;
 
 /// Initializes a new instance of FVPTextureBasedVideoPlayer with the given asset, frame updater,
 /// display link, AV factory, and registrar.
 - (instancetype)initWithAsset:(NSString *)asset
                  frameUpdater:(FVPFrameUpdater *)frameUpdater
                   displayLink:(NSObject<FVPDisplayLink> *)displayLink
                     avFactory:(id<FVPAVFactory>)avFactory
-                 viewProvider:(NSObject<FVPViewProvider> *)viewProvider
-                   onDisposed:(void (^)(int64_t))onDisposed;
+                 viewProvider:(NSObject<FVPViewProvider> *)viewProvider;
 
 /// Sets the texture Identifier for the frame updater. This method should be called once the texture
 /// identifier is obtained from the texture registry.