[video_player_avfoundation] iOS platform view support (flutter#8237)

This PR adds support for platform views on iOS as a way of displaying a
video. When creating a video, it's now possible to choose between
texture view approach (rendered using `Texture` widget on the Flutter
side) and platform view approach (rendered on the native side, using
`AVPlayerLayer`).

`FVPVideoPlayer` class now has nothing to do with texture. The
texture-related code was moved from it to `FVPTextureBasedVideoPlayer` -
a subclass of `FVPVideoPlayer` that adds texture functionality. In the
plugin class (`createWithOptions` method) we create either the basic
version (for platform view) or the texture subclass (in case of texture
approach) based on the parameter passed in from Flutter side.

Platform view is only supported on iOS, no MacOS implementation is added
in this PR. The functionality is not yet exposed in the app-facing
package (only in example app) - it will be done later, once we add the
Android implementation. The PR does not introduce breaking changes, I
followed the rule "non-breaking changes, even at the expense of a
less-clean API" (`buildViewWithOptions` and `createWithOptions`
methods).

Up to this point, the variable naming relied heavily on the texture (we
had a lot of `textureId` variables and properties). Since now you can
use a platform view instead of a texture view, these variables and
parameters were renamed to just `playerId`.

I left some comments in the PR to clarify/discuss some choices.

Resolves [#86613](flutter/flutter#86613) (not
fully though, as it is not yet available in the app-facing package).

## Pre-launch Checklist

- [x] I read the [Contributor Guide] and followed the process outlined
there for submitting PRs.
- [x] I read the [Tree Hygiene] page, which explains my
responsibilities.
- [x] I read and followed the [relevant style guides] and ran the
auto-formatter. (Unlike the flutter/flutter repo, the flutter/packages
repo does use `dart format`.)
- [x] I signed the [CLA].
- [x] The title of the PR starts with the name of the package surrounded
by square brackets, e.g. `[shared_preferences]`
- [x] I [linked to at least one issue that this PR fixes] in the
description above.
- [x] I updated `pubspec.yaml` with an appropriate new version according
to the [pub versioning philosophy], or this PR is [exempt from version
changes].
- [x] I updated `CHANGELOG.md` to add a description of the change,
[following repository CHANGELOG style], or this PR is [exempt from
CHANGELOG changes].
- [x] I updated/added relevant documentation (doc comments with `///`).
- [x] I added new tests to check the change I am making, or this PR is
[test-exempt].
- [x] All existing and new tests are passing.

If you need help, consider asking for advice on the #hackers-new channel
on [Discord].

<!-- Links -->
[Contributor Guide]:
https://github.com/flutter/packages/blob/main/CONTRIBUTING.md
[Tree Hygiene]:
https://github.com/flutter/flutter/blob/master/docs/contributing/Tree-hygiene.md
[relevant style guides]:
https://github.com/flutter/packages/blob/main/CONTRIBUTING.md#style
[CLA]: https://cla.developers.google.com/
[Discord]:
https://github.com/flutter/flutter/blob/master/docs/contributing/Chat.md
[linked to at least one issue that this PR fixes]:
https://github.com/flutter/flutter/blob/master/docs/contributing/Tree-hygiene.md#overview
[pub versioning philosophy]: https://dart.dev/tools/pub/versioning
[exempt from version changes]:
https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#version
[following repository CHANGELOG style]:
https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#changelog-style
[exempt from CHANGELOG changes]:
https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#changelog
[test-exempt]:
https://github.com/flutter/flutter/blob/master/docs/contributing/Tree-hygiene.md#tests

Author: FirentisTFW

packages/video_player/video_player_avfoundation/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.7.0
+
+* Adds support for platform views as an optional way of displaying a video.
+
 ## 2.6.7
 
 * Fixes playback speed resetting.

packages/video_player/video_player_avfoundation/README.md

@@ -13,3 +13,7 @@ should add it to your `pubspec.yaml` as usual.
 
 [1]: https://pub.dev/packages/video_player
 [2]: https://flutter.dev/to/endorsed-federated-plugin
+
+## Platform limitations
+
+On macOS, the plugin does not currently support platform views. Instead, a texture view is always used to display the video player, even if `VideoViewType.platformView` is specified as a parameter.

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

@@ -25,7 +25,7 @@ - (void)displayLinkFired {
   CMTime outputItemTime = [self.videoOutput itemTimeForHostTime:CACurrentMediaTime()];
   if ([self.videoOutput hasNewPixelBufferForItemTime:outputItemTime]) {
     _lastKnownAvailableTime = outputItemTime;
-    [_registry textureFrameAvailable:_textureId];
+    [_registry textureFrameAvailable:_textureIdentifier];
   }
 }
 @end

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

@@ -0,0 +1,198 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#import "./include/video_player_avfoundation/FVPTextureBasedVideoPlayer.h"
+#import "./include/video_player_avfoundation/FVPTextureBasedVideoPlayer_Test.h"
+
+@interface FVPTextureBasedVideoPlayer ()
+// The CALayer associated with the Flutter view this plugin is associated with, if any.
+@property(nonatomic, readonly) CALayer *flutterViewLayer;
+// The updater that drives callbacks to the engine to indicate that a new frame is ready.
+@property(nonatomic) FVPFrameUpdater *frameUpdater;
+// The display link that drives frameUpdater.
+@property(nonatomic) FVPDisplayLink *displayLink;
+// Whether a new frame needs to be provided to the engine regardless of the current play/pause state
+// (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:(FVPDisplayLink *)displayLink
+                    avFactory:(id<FVPAVFactory>)avFactory
+                    registrar:(NSObject<FlutterPluginRegistrar> *)registrar
+                   onDisposed:(void (^)(int64_t))onDisposed {
+  return [self initWithURL:[NSURL fileURLWithPath:[FVPVideoPlayer absolutePathForAssetName:asset]]
+              frameUpdater:frameUpdater
+               displayLink:displayLink
+               httpHeaders:@{}
+                 avFactory:avFactory
+                 registrar:registrar
+                onDisposed:onDisposed];
+}
+
+- (instancetype)initWithURL:(NSURL *)url
+               frameUpdater:(FVPFrameUpdater *)frameUpdater
+                displayLink:(FVPDisplayLink *)displayLink
+                httpHeaders:(nonnull NSDictionary<NSString *, NSString *> *)headers
+                  avFactory:(id<FVPAVFactory>)avFactory
+                  registrar:(NSObject<FlutterPluginRegistrar> *)registrar
+                 onDisposed:(void (^)(int64_t))onDisposed {
+  NSDictionary<NSString *, id> *options = nil;
+  if ([headers count] != 0) {
+    options = @{@"AVURLAssetHTTPHeaderFieldsKey" : headers};
+  }
+  AVURLAsset *urlAsset = [AVURLAsset URLAssetWithURL:url options:options];
+  AVPlayerItem *item = [AVPlayerItem playerItemWithAsset:urlAsset];
+  return [self initWithPlayerItem:item
+                     frameUpdater:frameUpdater
+                      displayLink:displayLink
+                        avFactory:avFactory
+                        registrar:registrar
+                       onDisposed:onDisposed];
+}
+
+- (instancetype)initWithPlayerItem:(AVPlayerItem *)item
+                      frameUpdater:(FVPFrameUpdater *)frameUpdater
+                       displayLink:(FVPDisplayLink *)displayLink
+                         avFactory:(id<FVPAVFactory>)avFactory
+                         registrar:(NSObject<FlutterPluginRegistrar> *)registrar
+                        onDisposed:(void (^)(int64_t))onDisposed {
+  self = [super initWithPlayerItem:item avFactory:avFactory registrar:registrar];
+
+  if (self) {
+    _frameUpdater = frameUpdater;
+    _displayLink = displayLink;
+    _frameUpdater.videoOutput = self.videoOutput;
+    _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
+    // video streams (not just iOS 16).  (https://github.com/flutter/flutter/issues/109116). An
+    // invisible AVPlayerLayer is used to overwrite the protection of pixel buffers in those streams
+    // for issue #1, and restore the correct width and height for issue #2.
+    _playerLayer = [AVPlayerLayer playerLayerWithPlayer:self.player];
+    [self.flutterViewLayer addSublayer:self.playerLayer];
+  }
+  return self;
+}
+
+- (void)setTextureIdentifier:(int64_t)textureIdentifier {
+  self.frameUpdater.textureIdentifier = textureIdentifier;
+}
+
+- (void)expectFrame {
+  self.waitingForFrame = YES;
+
+  _displayLink.running = YES;
+}
+
+#pragma mark - Private methods
+
+- (CALayer *)flutterViewLayer {
+#if TARGET_OS_OSX
+  return self.registrar.view.layer;
+#else
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  // TODO(hellohuanlin): Provide a non-deprecated codepath. See
+  // https://github.com/flutter/flutter/issues/104117
+  UIViewController *root = UIApplication.sharedApplication.keyWindow.rootViewController;
+#pragma clang diagnostic pop
+  return root.view.layer;
+#endif
+}
+
+#pragma mark - Overrides
+
+- (void)updatePlayingState {
+  [super updatePlayingState];
+  // If the texture is still waiting for an expected frame, the display link needs to keep
+  // running until it arrives regardless of the play/pause state.
+  _displayLink.running = self.isPlaying || self.waitingForFrame;
+}
+
+- (void)seekTo:(int64_t)location completionHandler:(void (^)(BOOL))completionHandler {
+  CMTime previousCMTime = self.player.currentTime;
+  [super seekTo:location
+      completionHandler:^(BOOL completed) {
+        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
+          // runs, and the display link stays on indefinitely, but that should be relatively
+          // harmless. This must use the display link rather than just informing the engine that a
+          // new frame is available because the seek completing doesn't guarantee that the pixel
+          // buffer is already available.
+          [self expectFrame];
+        }
+
+        if (completionHandler) {
+          completionHandler(completed);
+        }
+      }];
+}
+
+- (void)disposeSansEventChannel {
+  // This check prevents the crash caused by removing the KVO observers twice.
+  // When performing a Hot Restart, the leftover players are disposed once directly
+  // by [FVPVideoPlayerPlugin initialize:] method and then disposed again by
+  // [FVPVideoPlayer onTextureUnregistered:] call leading to possible over-release.
+  if (self.disposed) {
+    return;
+  }
+
+  [super disposeSansEventChannel];
+
+  [self.playerLayer removeFromSuperlayer];
+
+  _displayLink = nil;
+}
+
+- (void)dispose {
+  [super dispose];
+
+  _onDisposed(self.frameUpdater.textureIdentifier);
+}
+
+#pragma mark - FlutterTexture
+
+- (CVPixelBufferRef)copyPixelBuffer {
+  CVPixelBufferRef buffer = NULL;
+  CMTime outputItemTime = [self.videoOutput itemTimeForHostTime:CACurrentMediaTime()];
+  if ([self.videoOutput hasNewPixelBufferForItemTime:outputItemTime]) {
+    buffer = [self.videoOutput copyPixelBufferForItemTime:outputItemTime itemTimeForDisplay:NULL];
+  } else {
+    // If the current time isn't available yet, use the time that was checked when informing the
+    // engine that a frame was available (if any).
+    CMTime lastAvailableTime = self.frameUpdater.lastKnownAvailableTime;
+    if (CMTIME_IS_VALID(lastAvailableTime)) {
+      buffer = [self.videoOutput copyPixelBufferForItemTime:lastAvailableTime
+                                         itemTimeForDisplay:NULL];
+    }
+  }
+
+  if (self.waitingForFrame && buffer) {
+    self.waitingForFrame = NO;
+    // If the display link was only running temporarily to pick up a new frame while the video was
+    // paused, stop it again.
+    if (!self.isPlaying) {
+      self.displayLink.running = NO;
+    }
+  }
+
+  return buffer;
+}
+
+- (void)onTextureUnregistered:(NSObject<FlutterTexture> *)texture {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self.disposed) {
+      [self dispose];
+    }
+  });
+}
+
+@end