flutter · auto-submit · Jul 8, 2025 · Jun 28, 2025 · Jun 30, 2025 · Jun 30, 2025
@@ -1,3 +1,7 @@
+## 2.7.3
+
+* Restructures the communication between Dart and native code.
+
 ## 2.7.2
 
 * Uses `CADisplayLink` on macOS 14.0+.

@@ -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 {

@@ -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.

@@ -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

@@ -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.