flutter::FlutterPlatformViewsController Class Reference

#include <FlutterPlatformViews_Internal.h>

Instance Methods
()	- FlutterPlatformViewsController
()	- ~FlutterPlatformViewsController
(fml::WeakPtr< flutter::FlutterPlatformViewsController >)	- GetWeakPtr
(void)	- SetFlutterView
(void)	- SetFlutterViewController
(UIViewController< FlutterViewResponder > *)	- getFlutterViewController
(void)	- RegisterViewFactory
(void)	- BeginFrame
(void)	- CancelFrame
(void)	- PrerollCompositeEmbeddedView
(size_t)	- EmbeddedViewCount
(UIView *)	- GetPlatformViewByID
(FlutterTouchInterceptingView *)	- GetFlutterTouchInterceptingViewByID
(PostPrerollResult)	- PostPrerollAction
(void)	- EndFrame
(DlCanvas *)	- CompositeEmbeddedView
(SkRect)	- GetPlatformViewRect
(void)	- Reset
(bool)	- SubmitFrame
(void)	- OnMethodCall
(long)	- FindFirstResponderPlatformViewId
(void)	- PushFilterToVisitedPlatformViews
(void)	- PushVisitedPlatformView

Detailed Description

Definition at line 205 of file FlutterPlatformViews_Internal.h.

Constructor & Destructor Documentation

FlutterPlatformViewsController

- FlutterPlatformViewsController:

Definition at line 28 of file FlutterPlatformViews_Internal.mm.

    : layer_pool_(std::make_unique<FlutterPlatformViewLayerPool>()),
      weak_factory_(std::make_unique<fml::WeakPtrFactory<FlutterPlatformViewsController>>(this)) {
  mask_view_pool_.reset(
      [[FlutterClippingMaskViewPool alloc] initWithCapacity:kFlutterClippingMaskViewPoolCapacity]);
};

~FlutterPlatformViewsController

- FlutterPlatformViewsController:

Method Documentation

BeginFrame

- (void) FlutterPlatformViewsController:

(SkISize)

frame_size

Definition at line 315 of file FlutterPlatformViews.mm.

                                                                  {
  ResetFrameState();
  frame_size_ = frame_size;
}

CancelFrame

- (void) FlutterPlatformViewsController:

Definition at line 320 of file FlutterPlatformViews.mm.

                                                 {
  ResetFrameState();
}

CompositeEmbeddedView

- (DlCanvas *) FlutterPlatformViewsController:

(int64_t)

view_id

Definition at line 620 of file FlutterPlatformViews.mm.

                                                                               {
  // Any UIKit related code has to run on main thread.
  FML_DCHECK([[NSThread currentThread] isMainThread]);
  // Do nothing if the view doesn't need to be composited.
  if (views_to_recomposite_.count(view_id) == 0) {
    return slices_[view_id]->canvas();
  }
  CompositeWithParams(view_id, current_composition_params_[view_id]);
  views_to_recomposite_.erase(view_id);
  return slices_[view_id]->canvas();
}

EmbeddedViewCount

- (size_t) FlutterPlatformViewsController:

Definition at line 402 of file FlutterPlatformViews.mm.

                                                         {
  return composition_order_.size();
}

EndFrame

- (void) FlutterPlatformViewsController:		(bool)	should_resubmit_frame
		(const fml::RefPtr< fml::RasterThreadMerger > &)	raster_thread_merger

Definition at line 361 of file FlutterPlatformViews.mm.

                                                                  {
  if (should_resubmit_frame) {
    raster_thread_merger->MergeWithLease(kDefaultMergedLeaseDuration);
  }
}

FindFirstResponderPlatformViewId

- (long) FlutterPlatformViewsController:

Definition at line 418 of file FlutterPlatformViews.mm.

                                                                      {
  for (auto const& [id, root_view] : root_views_) {
    if ((UIView*)(root_view.get()).flt_hasFirstResponderInViewHierarchySubtree) {
      return id;
    }
  }
  return -1;
}

GetFlutterTouchInterceptingViewByID

- (FlutterTouchInterceptingView *) FlutterPlatformViewsController:

(int64_t)

view_id

Definition at line 410 of file FlutterPlatformViews.mm.

                     {
  if (views_.empty()) {
    return nil;
  }
  return touch_interceptors_[view_id].get();
}

getFlutterViewController

- (UIViewController< FlutterViewResponder > *) FlutterPlatformViewsController:

Definition at line 170 of file FlutterPlatformViews.mm.

                                                                                                 {
  return flutter_view_controller_.get();
}

GetPlatformViewByID

- (UIView *) FlutterPlatformViewsController:

(int64_t)

view_id

Definition at line 406 of file FlutterPlatformViews.mm.

                                                                           {
  return [GetFlutterTouchInterceptingViewByID(view_id) embeddedView];
}

GetPlatformViewRect

- (SkRect) FlutterPlatformViewsController:

(int64_t)

view_id

Definition at line 650 of file FlutterPlatformViews.mm.

                                                                          {
  UIView* platform_view = GetPlatformViewByID(view_id);
  UIScreen* screen = [UIScreen mainScreen];
  CGRect platform_view_cgrect = [platform_view convertRect:platform_view.bounds
                                                    toView:flutter_view_];
  return SkRect::MakeXYWH(platform_view_cgrect.origin.x * screen.scale,    //
                          platform_view_cgrect.origin.y * screen.scale,    //
                          platform_view_cgrect.size.width * screen.scale,  //
                          platform_view_cgrect.size.height * screen.scale  //
  );
}

GetWeakPtr

- (WeakPtr<) flutter:

Definition at line 37 of file FlutterPlatformViews_Internal.mm.

                                                                                             {
  return weak_factory_->GetWeakPtr();
}

OnMethodCall

- (void) FlutterPlatformViewsController:		(FlutterMethodCall *)	call
		(FlutterResult)	result

Definition at line 174 of file FlutterPlatformViews.mm.

                                                                                               {
  if ([[call method] isEqualToString:@"create"]) {
    OnCreate(call, result);
  } else if ([[call method] isEqualToString:@"dispose"]) {
    OnDispose(call, result);
  } else if ([[call method] isEqualToString:@"acceptGesture"]) {
    OnAcceptGesture(call, result);
  } else if ([[call method] isEqualToString:@"rejectGesture"]) {
    OnRejectGesture(call, result);
  } else {
    result(FlutterMethodNotImplemented);
  }
}

PostPrerollAction

- (PostPrerollResult) FlutterPlatformViewsController:

(const fml::RefPtr< fml::RasterThreadMerger > &)

raster_thread_merger

Definition at line 333 of file FlutterPlatformViews.mm.

                                                                  {
  // TODO(cyanglaz): https://github.com/flutter/flutter/issues/56474
  // Rename `has_platform_view` to `view_mutated` when the above issue is resolved.
  if (!HasPlatformViewThisOrNextFrame()) {
    return PostPrerollResult::kSuccess;
  }
  if (!raster_thread_merger->IsMerged()) {
    // The raster thread merger may be disabled if the rasterizer is being
    // created or teared down.
    //
    // In such cases, the current frame is dropped, and a new frame is attempted
    // with the same layer tree.
    //
    // Eventually, the frame is submitted once this method returns `kSuccess`.
    // At that point, the raster tasks are handled on the platform thread.
    CancelFrame();
    return PostPrerollResult::kSkipAndRetryFrame;
  }
  // If the post preroll action is successful, we will display platform views in the current frame.
  // In order to sync the rendering of the platform views (quartz) with skia's rendering,
  // We need to begin an explicit CATransaction. This transaction needs to be submitted
  // after the current frame is submitted.
  BeginCATransaction();
  raster_thread_merger->ExtendLeaseTo(kDefaultMergedLeaseDuration);
  return PostPrerollResult::kSuccess;
}

PrerollCompositeEmbeddedView

- (void) FlutterPlatformViewsController:		(int64_t)	view_id
		(std::unique_ptr< flutter::EmbeddedViewParams >)	params

Definition at line 379 of file FlutterPlatformViews.mm.

                                              {
  // All the CATransactions should be committed by the end of the last frame,
  // so catransaction_added_ must be false.
  FML_DCHECK(!catransaction_added_);
 
  SkRect view_bounds = SkRect::Make(frame_size_);
  std::unique_ptr<EmbedderViewSlice> view;
  view = std::make_unique<DisplayListEmbedderViewSlice>(view_bounds);
  slices_.insert_or_assign(view_id, std::move(view));
 
  composition_order_.push_back(view_id);
 
  if (current_composition_params_.count(view_id) == 1 &&
      current_composition_params_[view_id] == *params.get()) {
    // Do nothing if the params didn't change.
    return;
  }
  current_composition_params_[view_id] = EmbeddedViewParams(*params.get());
  views_to_recomposite_.insert(view_id);
}

PushFilterToVisitedPlatformViews

- (void) FlutterPlatformViewsController:		(const std::shared_ptr< const DlImageFilter > &)	filter
		(const SkRect &)	filter_rect

Definition at line 369 of file FlutterPlatformViews.mm.

                               {
  for (int64_t id : visited_platform_views_) {
    EmbeddedViewParams params = current_composition_params_[id];
    params.PushImageFilter(filter, filter_rect);
    current_composition_params_[id] = params;
  }
}

PushVisitedPlatformView

- (void) FlutterPlatformViewsController:

(int64_t)

view_id

Definition at line 280 of file FlutterPlatformViews_Internal.h.

{ visited_platform_views_.push_back(view_id); }

RegisterViewFactory

- (void) FlutterPlatformViewsController:		(NSObject< FlutterPlatformViewFactory > *)	factory
		(NSString *)	factoryId
		(FlutterPlatformViewGestureRecognizersBlockingPolicy)	gestureRecognizerBlockingPolicy

Definition at line 304 of file FlutterPlatformViews.mm.

                                                                                         {
  std::string idString([factoryId UTF8String]);
  FML_CHECK(factories_.count(idString) == 0);
  factories_[idString] =
      fml::scoped_nsobject<NSObject<FlutterPlatformViewFactory>>([factory retain]);
  gesture_recognizers_blocking_policies_[idString] = gestureRecognizerBlockingPolicy;
}

Reset

- (void) FlutterPlatformViewsController:

Definition at line 632 of file FlutterPlatformViews.mm.

                                           {
  for (int64_t view_id : active_composition_order_) {
    UIView* sub_view = root_views_[view_id].get();
    [sub_view removeFromSuperview];
  }
  root_views_.clear();
  touch_interceptors_.clear();
  views_.clear();
  composition_order_.clear();
  active_composition_order_.clear();
  slices_.clear();
  current_composition_params_.clear();
  clip_count_.clear();
  views_to_recomposite_.clear();
  layer_pool_->RecycleLayers();
  visited_platform_views_.clear();
}

SetFlutterView

- (void) FlutterPlatformViewsController:

(UIView *)

flutter_view

Definition at line 161 of file FlutterPlatformViews.mm.

                                                                        {
  flutter_view_.reset([flutter_view retain]);
}

SetFlutterViewController

- (void) FlutterPlatformViewsController:

(UIViewController< FlutterViewResponder > *)

flutter_view_controller

Definition at line 165 of file FlutterPlatformViews.mm.

                                                                     {
  flutter_view_controller_.reset([flutter_view_controller retain]);
}

SubmitFrame

- (bool) FlutterPlatformViewsController:		(GrDirectContext *)	gr_context
		(const std::shared_ptr< IOSContext > &)	ios_context
		(std::unique_ptr< SurfaceFrame >)	frame

Definition at line 662 of file FlutterPlatformViews.mm.

                                                                                    {
  TRACE_EVENT0("flutter", "FlutterPlatformViewsController::SubmitFrame");
 
  // Any UIKit related code has to run on main thread.
  FML_DCHECK([[NSThread currentThread] isMainThread]);
  if (flutter_view_ == nullptr) {
    return frame->Submit();
  }
 
  DisposeViews();
 
  DlCanvas* background_canvas = frame->Canvas();
 
  // Resolve all pending GPU operations before allocating a new surface.
  background_canvas->Flush();
 
  // Clipping the background canvas before drawing the picture recorders requires
  // saving and restoring the clip context.
  DlAutoCanvasRestore save(background_canvas, /*do_save=*/true);
 
  // Maps a platform view id to a vector of `FlutterPlatformViewLayer`.
  LayersMap platform_view_layers;
 
  auto did_submit = true;
  auto num_platform_views = composition_order_.size();
 
  // TODO(hellohuanlin) this double for-loop is expensive with wasted computations.
  // See: https://github.com/flutter/flutter/issues/145802
  for (size_t i = 0; i < num_platform_views; i++) {
    int64_t platform_view_id = composition_order_[i];
    EmbedderViewSlice* slice = slices_[platform_view_id].get();
    slice->end_recording();
 
    // Check if the current picture contains overlays that intersect with the
    // current platform view or any of the previous platform views.
    for (size_t j = i + 1; j > 0; j--) {
      int64_t current_platform_view_id = composition_order_[j - 1];
      SkRect platform_view_rect = GetPlatformViewRect(current_platform_view_id);
      std::vector<SkIRect> intersection_rects = slice->region(platform_view_rect).getRects();
      const SkIRect rounded_in_platform_view_rect = platform_view_rect.roundIn();
      // Ignore intersections of single width/height on the edge of the platform view.
      // This is to address the following performance issue when interleaving adjacent
      // platform views and layers:
      // Since we `roundOut` both platform view rects and the layer rects, as long as
      // the coordinate is fractional, there will be an intersection of a single pixel width
      // (or height) after rounding out, even if they do not intersect before rounding out.
      // We have to round out both platform view rect and the layer rect.
      // Rounding in platform view rect will result in missing pixel on the intersection edge.
      // Rounding in layer rect will result in missing pixel on the edge of the layer on top
      // of the platform view.
      for (auto it = intersection_rects.begin(); it != intersection_rects.end(); /*no-op*/) {
        // If intersection_rect does not intersect with the *rounded in* platform
        // view rect, then the intersection must be a single pixel width (or height) on edge.
        if (!SkIRect::Intersects(*it, rounded_in_platform_view_rect)) {
          it = intersection_rects.erase(it);
        } else {
          ++it;
        }
      }
 
      auto allocation_size = intersection_rects.size();
 
      // For testing purposes, the overlay id is used to find the overlay view.
      // This is the index of the layer for the current platform view.
      auto overlay_id = platform_view_layers[current_platform_view_id].size();
 
      // If the max number of allocations per platform view is exceeded,
      // then join all the rects into a single one.
      //
      // TODO(egarciad): Consider making this configurable.
      // https://github.com/flutter/flutter/issues/52510
      if (allocation_size > kMaxLayerAllocations) {
        SkIRect joined_rect = SkIRect::MakeEmpty();
        for (const SkIRect& rect : intersection_rects) {
          joined_rect.join(rect);
        }
        // Replace the rects in the intersection rects list for a single rect that is
        // the union of all the rects in the list.
        intersection_rects.clear();
        intersection_rects.push_back(joined_rect);
      }
      for (SkIRect& joined_rect : intersection_rects) {
        // Get the intersection rect between the current rect
        // and the platform view rect.
        joined_rect.intersect(platform_view_rect.roundOut());
        // Clip the background canvas, so it doesn't contain any of the pixels drawn
        // on the overlay layer.
        background_canvas->ClipRect(SkRect::Make(joined_rect), DlCanvas::ClipOp::kDifference);
        // Get a new host layer.
        std::shared_ptr<FlutterPlatformViewLayer> layer =
            GetLayer(gr_context,                                      //
                     ios_context,                                     //
                     slice,                                           //
                     joined_rect,                                     //
                     current_platform_view_id,                        //
                     overlay_id,                                      //
                     ((FlutterView*)flutter_view_.get()).pixelFormat  //
            );
        did_submit &= layer->did_submit_last_frame;
        platform_view_layers[current_platform_view_id].push_back(layer);
        overlay_id++;
      }
    }
    slice->render_into(background_canvas);
  }
 
  // Manually trigger the SkAutoCanvasRestore before we submit the frame
  save.Restore();
 
  // If a layer was allocated in the previous frame, but it's not used in the current frame,
  // then it can be removed from the scene.
  RemoveUnusedLayers();
  // Organize the layers by their z indexes.
  BringLayersIntoView(platform_view_layers);
  // Mark all layers as available, so they can be used in the next frame.
  layer_pool_->RecycleLayers();
 
  did_submit &= frame->Submit();
 
  // If the frame is submitted with embedded platform views,
  // there should be a |[CATransaction begin]| call in this frame prior to all the drawing.
  // If that case, we need to commit the transaction.
  CommitCATransactionIfNeeded();
  return did_submit;
}

---

The documentation for this class was generated from the following files:

• shell/platform/darwin/ios/framework/Source/FlutterPlatformViews_Internal.h
• shell/platform/darwin/ios/framework/Source/FlutterPlatformViews.mm
• shell/platform/darwin/ios/framework/Source/FlutterPlatformViews_Internal.mm