Add additional state to manage frame status and CALayers to FlutterGLCompositor

Author: RichardJCai

shell/platform/darwin/macos/framework/Source/FlutterBackingStoreData.h

@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#import "flutter/shell/platform/darwin/macos/framework/Source/FlutterFrameBufferProvider.h"
+#import "flutter/shell/platform/darwin/macos/framework/Source/FlutterIOSurfaceHolder.h"
+
 #import <Cocoa/Cocoa.h>
 
 /**
@@ -10,8 +13,12 @@
  */
 @interface FlutterBackingStoreData : NSObject
 
-- (nullable instancetype)initWithIsRootView:(bool)isRootView;
+- (nullable instancetype)initWithLayerId:(size_t)layerId
+                              fbProvider:(nonnull FlutterFrameBufferProvider*)fbProvider
+                         ioSurfaceHolder:(nonnull FlutterIOSurfaceHolder*)ioSurfaceHolder;
 
-- (bool)isRootView;
+- (size_t)getLayerId;
+- (nonnull FlutterFrameBufferProvider*)getFrameBufferProvider;
+- (nonnull FlutterIOSurfaceHolder*)getIOSurfaceHolder;
 
 @end

shell/platform/darwin/macos/framework/Source/FlutterBackingStoreData.mm

@@ -3,25 +3,40 @@
 // found in the LICENSE file.
 
 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterBackingStoreData.h"
+#import "flutter/shell/platform/darwin/macos/framework/Source/FlutterFrameBufferProvider.h"
+#import "flutter/shell/platform/darwin/macos/framework/Source/FlutterIOSurfaceHolder.h"
 
 #include <OpenGL/gl.h>
 
 @interface FlutterBackingStoreData () {
-  bool _isRootView;
+  size_t _layerId;
+  FlutterFrameBufferProvider* _fbProvider;
+  FlutterIOSurfaceHolder* _ioSurfaceHolder;
 }
 @end
 
 @implementation FlutterBackingStoreData
 
-- (nullable instancetype)initWithIsRootView:(bool)isRootView {
+- (nullable instancetype)initWithLayerId:(size_t)layerId
+                              fbProvider:(nonnull FlutterFrameBufferProvider*)fbProvider
+                         ioSurfaceHolder:(nonnull FlutterIOSurfaceHolder*)ioSurfaceHolder {
   if (self = [super init]) {
-    _isRootView = isRootView;
+    _layerId = layerId;
+    _fbProvider = fbProvider;
+    _ioSurfaceHolder = ioSurfaceHolder;
   }
   return self;
 }
 
-- (bool)isRootView {
-  return _isRootView;
+- (size_t)getLayerId {
+  return _layerId;
+}
+
+- (nonnull FlutterFrameBufferProvider*)getFrameBufferProvider {
+  return _fbProvider;
+}
+- (nonnull FlutterIOSurfaceHolder*)getIOSurfaceHolder {
+  return _ioSurfaceHolder;
 }
 
 @end

shell/platform/darwin/macos/framework/Source/FlutterEngine.mm

@@ -405,6 +405,8 @@ - (FlutterCompositor*)createFlutterCompositor {
   _macOSGLCompositor->SetPresentCallback(
       [weak_self]() { return [weak_self engineCallbackOnPresent]; });
 
+  _compositor.avoid_cache = true;
+
   return &_compositor;
 }
 

shell/platform/darwin/macos/framework/Source/FlutterGLCompositor.h

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <vector>
+#include <map>
 
 #include "flutter/fml/macros.h"
 #include "flutter/shell/platform/darwin/macos/framework/Source/FlutterSurfaceManager.h"
@@ -38,6 +38,7 @@ class FlutterGLCompositor {
 
   // Presents the FlutterLayers by updating FlutterView(s) using the
   // layer content.
+  // Present sets frame_started_ to false.
   bool Present(const FlutterLayer** layers, size_t layers_count);
 
   using PresentCallback = std::function<bool()>;
@@ -50,6 +51,26 @@ class FlutterGLCompositor {
   PresentCallback present_callback_;
   NSOpenGLContext* open_gl_context_;
 
+  // State to manage CALayers for rendering content.
+  size_t ca_layer_count_ = 0;
+
+  // Maps a layer_id (size_t) to a CALayer.
+  // The layer_id starts at 0 for a given frame
+  // and increments by 1 for each new CALayer.
+  std::map<size_t, CALayer*> ca_layer_map_;
+
+  // frame_started_ keeps track of if a layer has been
+  // created for the frame.
+  bool frame_started_ = false;
+
+  // Set frame_started_ to true and reset all layer state.
+  void StartFrame();
+
+  // Creates a CALayer and adds it to ca_layer_map_ and increments
+  // ca_layer_count_; Returns the key value (size_t) for the layer in
+  // ca_layer_map_.
+  size_t CreateCALayer();
+
   FML_DISALLOW_COPY_AND_ASSIGN(FlutterGLCompositor);
 };
 

shell/platform/darwin/macos/framework/Source/FlutterGLCompositor.mm

@@ -26,25 +26,36 @@
 bool FlutterGLCompositor::CreateBackingStore(const FlutterBackingStoreConfig* config,
                                              FlutterBackingStore* backing_store_out) {
   CGSize size = CGSizeMake(config->size.width, config->size.height);
-  FlutterBackingStoreData* data =
-      [[FlutterBackingStoreData alloc] initWithIsRootView:config->is_root_view];
 
-  backing_store_out->type = kFlutterBackingStoreTypeOpenGL;
-  backing_store_out->is_cacheable = true;
-  backing_store_out->open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
-  backing_store_out->open_gl.framebuffer.target = GL_RGBA8;
-
-  if (config->is_root_view) {
-    // The root view uses FlutterSurfaceManager and is not cacheable since
-    // the fbo id changes on every present.
-    backing_store_out->is_cacheable = false;
+  if (!frame_started_) {
+    StartFrame();
+    // If the backing store is for the first layer, return the fbo for the
+    // FlutterView.
     auto fbo = [view_controller_.flutterView frameBufferIDForSize:size];
     backing_store_out->open_gl.framebuffer.name = fbo;
   } else {
-    FML_CHECK(false) << "Compositor only supports creating a backing store for the root view";
+    FlutterFrameBufferProvider* fb_provider =
+        [[FlutterFrameBufferProvider alloc] initWithOpenGLContext:open_gl_context_];
+    FlutterIOSurfaceHolder* io_surface_holder = [FlutterIOSurfaceHolder alloc];
+
+    GLuint fbo = [fb_provider glFrameBufferId];
+    GLuint texture = [fb_provider glTextureId];
+
+    size_t layer_id = CreateCALayer();
+
+    [io_surface_holder bindSurfaceToTexture:texture fbo:fbo size:size];
+    FlutterBackingStoreData* data =
+        [[FlutterBackingStoreData alloc] initWithLayerId:layer_id
+                                              fbProvider:fb_provider
+                                         ioSurfaceHolder:io_surface_holder];
+
+    backing_store_out->open_gl.framebuffer.name = fbo;
+    backing_store_out->open_gl.framebuffer.user_data = (__bridge_retained void*)data;
   }
 
-  backing_store_out->open_gl.framebuffer.user_data = (__bridge_retained void*)data;
+  backing_store_out->type = kFlutterBackingStoreTypeOpenGL;
+  backing_store_out->open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
+  backing_store_out->open_gl.framebuffer.target = GL_RGBA8;
   backing_store_out->open_gl.framebuffer.destruction_callback = [](void* user_data) {
     if (user_data != nullptr) {
       CFRelease(user_data);
@@ -64,19 +75,33 @@
     FlutterBackingStore* backing_store = const_cast<FlutterBackingStore*>(layer->backing_store);
     switch (layer->type) {
       case kFlutterLayerContentTypeBackingStore: {
-        FlutterBackingStoreData* data =
-            (__bridge FlutterBackingStoreData*)(backing_store->open_gl.framebuffer.user_data);
-        if (![data isRootView]) {
-          FML_CHECK(false) << "Compositor only supports presenting the root view.";
+        if (backing_store->open_gl.framebuffer.user_data) {
+          FlutterBackingStoreData* backing_store_data =
+              (__bridge FlutterBackingStoreData*)backing_store->open_gl.framebuffer.user_data;
+
+          FlutterIOSurfaceHolder* io_surface_holder = [backing_store_data getIOSurfaceHolder];
+          size_t layer_id = [backing_store_data getLayerId];
+
+          CALayer* content_layer = ca_layer_map_[layer_id];
+
+          FML_CHECK(content_layer) << "Unable to find a content layer with layer id " << layer_id;
+
+          content_layer.frame = content_layer.superlayer.bounds;
+          content_layer.transform = CATransform3DMakeScale(1, -1, 1);
+          IOSurfaceRef io_surface_contents = [io_surface_holder ioSurface];
+          [content_layer setContents:(__bridge id)io_surface_contents];
         }
         break;
       }
       case kFlutterLayerContentTypePlatformView:
         // Add functionality in follow up PR.
-        FML_CHECK(false) << "Presenting PlatformViews not yet supported";
+        FML_LOG(WARNING) << "Presenting PlatformViews not yet supported";
         break;
     };
   }
+  // The frame has been presented, prepare FlutterGLCompositor to
+  // render a new frame.
+  frame_started_ = false;
   return present_callback_();
 }
 
@@ -85,4 +110,29 @@
   present_callback_ = present_callback;
 }
 
+void FlutterGLCompositor::StartFrame() {
+  // First reset all the state.
+  ca_layer_count_ = 0;
+
+  // First remove all CALayers from the superlayer.
+  for (auto const& x : ca_layer_map_) {
+    [x.second removeFromSuperlayer];
+  }
+
+  // Reset layer map.
+  ca_layer_map_.clear();
+
+  frame_started_ = true;
+}
+
+size_t FlutterGLCompositor::CreateCALayer() {
+  // FlutterGLCompositor manages the lifecycle of content layers.
+  // The id for a CALayer starts at 0 and increments by 1 for
+  // any given frame.
+  CALayer* content_layer = [[CALayer alloc] init];
+  [view_controller_.flutterView.layer addSublayer:content_layer];
+  ca_layer_map_[ca_layer_count_] = content_layer;
+  return ca_layer_count_++;
+}
+
 }  // namespace flutter