flutter::AndroidExternalViewEmbedder Class Reference

#include <external_view_embedder.h>

Inheritance diagram for flutter::AndroidExternalViewEmbedder:

Public Member Functions
	AndroidExternalViewEmbedder (const AndroidContext &android_context, std::shared_ptr< PlatformViewAndroidJNI > jni_facade, std::shared_ptr< AndroidSurfaceFactory > surface_factory, const TaskRunners &task_runners)
void	PrerollCompositeEmbeddedView (int64_t view_id, std::unique_ptr< flutter::EmbeddedViewParams > params) override
DlCanvas *	CompositeEmbeddedView (int64_t view_id) override
void	SubmitFlutterView (int64_t flutter_view_id, GrDirectContext *context, const std::shared_ptr< impeller::AiksContext > &aiks_context, std::unique_ptr< SurfaceFrame > frame) override
PostPrerollResult	PostPrerollAction (const fml::RefPtr< fml::RasterThreadMerger > &raster_thread_merger) override
DlCanvas *	GetRootCanvas () override
void	BeginFrame (GrDirectContext *context, const fml::RefPtr< fml::RasterThreadMerger > &raster_thread_merger) override
void	PrepareFlutterView (SkISize frame_size, double device_pixel_ratio) override
void	CancelFrame () override
void	EndFrame (bool should_resubmit_frame, const fml::RefPtr< fml::RasterThreadMerger > &raster_thread_merger) override
bool	SupportsDynamicThreadMerging () override
void	Teardown () override
SkRect	GetViewRect (int64_t view_id) const
Public Member Functions inherited from flutter::ExternalViewEmbedder
	ExternalViewEmbedder ()=default
virtual	~ExternalViewEmbedder ()=default
virtual void	CollectView (int64_t view_id)
virtual DlCanvas *	GetRootCanvas ()=0
virtual void	CancelFrame ()=0
virtual void	BeginFrame (GrDirectContext *context, const fml::RefPtr< fml::RasterThreadMerger > &raster_thread_merger)=0
virtual void	PrerollCompositeEmbeddedView (int64_t platform_view_id, std::unique_ptr< EmbeddedViewParams > params)=0
virtual PostPrerollResult	PostPrerollAction (const fml::RefPtr< fml::RasterThreadMerger > &raster_thread_merger)
virtual DlCanvas *	CompositeEmbeddedView (int64_t platform_view_id)=0
virtual void	PrepareFlutterView (SkISize frame_size, double device_pixel_ratio)=0
virtual void	SubmitFlutterView (int64_t flutter_view_id, GrDirectContext *context, const std::shared_ptr< impeller::AiksContext > &aiks_context, std::unique_ptr< SurfaceFrame > frame)
virtual void	EndFrame (bool should_resubmit_frame, const fml::RefPtr< fml::RasterThreadMerger > &raster_thread_merger)
virtual bool	SupportsDynamicThreadMerging ()
virtual void	Teardown ()
void	SetUsedThisFrame (bool used_this_frame)
bool	GetUsedThisFrame () const
virtual void	PushVisitedPlatformView (int64_t platform_view_id)
virtual void	PushFilterToVisitedPlatformViews (const std::shared_ptr< const DlImageFilter > &filter, const SkRect &filter_rect)

Detailed Description

Allows to embed Android views into a Flutter application.

This class calls Java methods via |PlatformViewAndroidJNI| to manage the lifecycle of the Android view corresponding to |flutter::PlatformViewLayer|.

It also orchestrates overlay surfaces. These are Android views that render above (by Z order) the Android view corresponding to |flutter::PlatformViewLayer|.

Definition at line 29 of file external_view_embedder.h.

Constructor & Destructor Documentation

AndroidExternalViewEmbedder()

flutter::AndroidExternalViewEmbedder::AndroidExternalViewEmbedder	(	const AndroidContext &	android_context,
		std::shared_ptr< PlatformViewAndroidJNI >	jni_facade,
		std::shared_ptr< AndroidSurfaceFactory >	surface_factory,
		const TaskRunners &	task_runners
	)

Definition at line 12 of file external_view_embedder.cc.

    : ExternalViewEmbedder(),
      android_context_(android_context),
      jni_facade_(std::move(jni_facade)),
      surface_factory_(std::move(surface_factory)),
      surface_pool_(std::make_unique<SurfacePool>()),
      task_runners_(task_runners) {}

Member Function Documentation

BeginFrame()

void flutter::AndroidExternalViewEmbedder::BeginFrame ( GrDirectContext *  context, const fml::RefPtr< fml::RasterThreadMerger > &  raster_thread_merger  )

overridevirtual

Implements flutter::ExternalViewEmbedder.

Definition at line 264 of file external_view_embedder.cc.

                                                                  {
  // JNI method must be called on the platform thread.
  if (raster_thread_merger->IsOnPlatformThread()) {
    jni_facade_->FlutterViewBeginFrame();
  }
}

CancelFrame()

void flutter::AndroidExternalViewEmbedder::CancelFrame ( )

overridevirtual

Implements flutter::ExternalViewEmbedder.

Definition at line 291 of file external_view_embedder.cc.

                                              {
  Reset();
}

CompositeEmbeddedView()

DlCanvas * flutter::AndroidExternalViewEmbedder::CompositeEmbeddedView ( int64_t  view_id )

overridevirtual

Implements flutter::ExternalViewEmbedder.

Definition at line 46 of file external_view_embedder.cc.

                                                                            {
  if (slices_.count(view_id) == 1) {
    return slices_.at(view_id)->canvas();
  }
  return nullptr;
}

EndFrame()

void flutter::AndroidExternalViewEmbedder::EndFrame ( bool  should_resubmit_frame, const fml::RefPtr< fml::RasterThreadMerger > &  raster_thread_merger  )

overridevirtual

Reimplemented from flutter::ExternalViewEmbedder.

Definition at line 296 of file external_view_embedder.cc.

                                                                  {
  surface_pool_->RecycleLayers();
  // JNI method must be called on the platform thread.
  if (raster_thread_merger->IsOnPlatformThread()) {
    jni_facade_->FlutterViewEndFrame();
  }
}

GetRootCanvas()

DlCanvas * flutter::AndroidExternalViewEmbedder::GetRootCanvas ( )

overridevirtual

Implements flutter::ExternalViewEmbedder.

Definition at line 251 of file external_view_embedder.cc.

                                                     {
  // On Android, the root surface is created from the on-screen render target.
  return nullptr;
}

GetViewRect()

SkRect flutter::AndroidExternalViewEmbedder::GetViewRect

(

int64_t

view_id

)

const

Definition at line 53 of file external_view_embedder.cc.

                                                                     {
  const EmbeddedViewParams& params = view_params_.at(view_id);
  // TODO(egarciad): The rect should be computed from the mutator stack.
  // (Clipping is missing)
  // https://github.com/flutter/flutter/issues/59821
  return SkRect::MakeXYWH(params.finalBoundingRect().x(),      //
                          params.finalBoundingRect().y(),      //
                          params.finalBoundingRect().width(),  //
                          params.finalBoundingRect().height()  //
  );
}

PostPrerollAction()

PostPrerollResult flutter::AndroidExternalViewEmbedder::PostPrerollAction ( const fml::RefPtr< fml::RasterThreadMerger > &  raster_thread_merger )

overridevirtual

Reimplemented from flutter::ExternalViewEmbedder.

Definition at line 219 of file external_view_embedder.cc.

                                                                  {
  if (!FrameHasPlatformLayers()) {
    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();
    raster_thread_merger->MergeWithLease(kDefaultMergedLeaseDuration);
    return PostPrerollResult::kSkipAndRetryFrame;
  }
  raster_thread_merger->ExtendLeaseTo(kDefaultMergedLeaseDuration);
  // Surface switch requires to resubmit the frame.
  // TODO(egarciad): https://github.com/flutter/flutter/issues/65652
  if (previous_frame_view_count_ == 0) {
    return PostPrerollResult::kResubmitFrame;
  }
  return PostPrerollResult::kSuccess;
}

PrepareFlutterView()

void flutter::AndroidExternalViewEmbedder::PrepareFlutterView ( SkISize  frame_size, double  device_pixel_ratio  )

overridevirtual

Implements flutter::ExternalViewEmbedder.

Definition at line 274 of file external_view_embedder.cc.

                               {
  Reset();
 
  // The surface size changed. Therefore, destroy existing surfaces as
  // the existing surfaces in the pool can't be recycled.
  if (frame_size_ != frame_size) {
    DestroySurfaces();
  }
  surface_pool_->SetFrameSize(frame_size);
 
  frame_size_ = frame_size;
  device_pixel_ratio_ = device_pixel_ratio;
}

PrerollCompositeEmbeddedView()

void flutter::AndroidExternalViewEmbedder::PrerollCompositeEmbeddedView ( int64_t  view_id, std::unique_ptr< flutter::EmbeddedViewParams >  params  )

overridevirtual

Implements flutter::ExternalViewEmbedder.

Definition at line 25 of file external_view_embedder.cc.

                                              {
  TRACE_EVENT0("flutter",
               "AndroidExternalViewEmbedder::PrerollCompositeEmbeddedView");
 
  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);
  // Update params only if they changed.
  if (view_params_.count(view_id) == 1 &&
      view_params_.at(view_id) == *params.get()) {
    return;
  }
  view_params_.insert_or_assign(view_id, EmbeddedViewParams(*params.get()));
}

SubmitFlutterView()

void flutter::AndroidExternalViewEmbedder::SubmitFlutterView ( int64_t  flutter_view_id, GrDirectContext *  context, const std::shared_ptr< impeller::AiksContext > &  aiks_context, std::unique_ptr< SurfaceFrame >  frame  )

overridevirtual

Reimplemented from flutter::ExternalViewEmbedder.

Definition at line 66 of file external_view_embedder.cc.

                                       {
  TRACE_EVENT0("flutter", "AndroidExternalViewEmbedder::SubmitFlutterView");
  // TODO(dkwingsmt): This class only supports rendering into the implicit view.
  // Properly support multi-view in the future.
  FML_DCHECK(flutter_view_id == kFlutterImplicitViewId);
 
  if (!FrameHasPlatformLayers()) {
    frame->Submit();
    return;
  }
 
  std::unordered_map<int64_t, SkRect> overlay_layers;
  DlCanvas* background_canvas = frame->Canvas();
  auto current_frame_view_count = composition_order_.size();
 
  // Restore the clip context after exiting this method since it's changed
  // below.
  DlAutoCanvasRestore save(background_canvas, /*do_save=*/true);
 
  for (size_t i = 0; i < current_frame_view_count; i++) {
    int64_t view_id = composition_order_[i];
    EmbedderViewSlice* slice = slices_.at(view_id).get();
    if (slice->canvas() == nullptr) {
      continue;
    }
 
    slice->end_recording();
 
    SkRect full_joined_rect = SkRect::MakeEmpty();
 
    // Determinate if Flutter UI intersects with any of the previous
    // platform views stacked by z position.
    //
    // This is done by querying the r-tree that holds the records for the
    // picture recorder corresponding to the flow layers added after a platform
    // view layer.
    for (ssize_t j = i; j >= 0; j--) {
      int64_t current_view_id = composition_order_[j];
      SkRect current_view_rect = GetViewRect(current_view_id);
      // The rect above the `current_view_rect`
      SkRect partial_joined_rect = SkRect::MakeEmpty();
      // Each rect corresponds to a native view that renders Flutter UI.
      std::vector<SkIRect> intersection_rects =
          slice->region(current_view_rect).getRects();
 
      // Limit the number of native views, so it doesn't grow forever.
      //
      // In this case, the rects are merged into a single one that is the union
      // of all the rects.
      for (const SkIRect& rect : intersection_rects) {
        partial_joined_rect.join(SkRect::Make(rect));
      }
      // Get the intersection rect with the `current_view_rect`,
      partial_joined_rect.intersect(current_view_rect);
      // Join the `partial_joined_rect` into `full_joined_rect` to get the rect
      // above the current `slice`
      full_joined_rect.join(partial_joined_rect);
    }
    if (!full_joined_rect.isEmpty()) {
      // Subpixels in the platform may not align with the canvas subpixels.
      //
      // To workaround it, round the floating point bounds and make the rect
      // slightly larger.
      //
      // For example, {0.3, 0.5, 3.1, 4.7} becomes {0, 0, 4, 5}.
      full_joined_rect.set(full_joined_rect.roundOut());
      overlay_layers.insert({view_id, full_joined_rect});
      // Clip the background canvas, so it doesn't contain any of the pixels
      // drawn on the overlay layer.
      background_canvas->ClipRect(full_joined_rect,
                                  DlCanvas::ClipOp::kDifference);
    }
    slice->render_into(background_canvas);
  }
 
  // Manually trigger the DlAutoCanvasRestore before we submit the frame
  save.Restore();
 
  // Submit the background canvas frame before switching the GL context to
  // the overlay surfaces.
  //
  // Skip a frame if the embedding is switching surfaces, and indicate in
  // `PostPrerollAction` that this frame must be resubmitted.
  auto should_submit_current_frame = previous_frame_view_count_ > 0;
  if (should_submit_current_frame) {
    frame->Submit();
  }
 
  for (int64_t view_id : composition_order_) {
    SkRect view_rect = GetViewRect(view_id);
    const EmbeddedViewParams& params = view_params_.at(view_id);
    // Display the platform view. If it's already displayed, then it's
    // just positioned and sized.
    jni_facade_->FlutterViewOnDisplayPlatformView(
        view_id,             //
        view_rect.x(),       //
        view_rect.y(),       //
        view_rect.width(),   //
        view_rect.height(),  //
        params.sizePoints().width() * device_pixel_ratio_,
        params.sizePoints().height() * device_pixel_ratio_,
        params.mutatorsStack()  //
    );
    std::unordered_map<int64_t, SkRect>::const_iterator overlay =
        overlay_layers.find(view_id);
    if (overlay == overlay_layers.end()) {
      continue;
    }
    std::unique_ptr<SurfaceFrame> frame =
        CreateSurfaceIfNeeded(context,                    //
                              view_id,                    //
                              slices_.at(view_id).get(),  //
                              overlay->second             //
        );
    if (should_submit_current_frame) {
      frame->Submit();
    }
  }
}

SupportsDynamicThreadMerging()

bool flutter::AndroidExternalViewEmbedder::SupportsDynamicThreadMerging ( )

overridevirtual

Reimplemented from flutter::ExternalViewEmbedder.

Definition at line 307 of file external_view_embedder.cc.

                                                               {
  return true;
}

Teardown()

void flutter::AndroidExternalViewEmbedder::Teardown ( )

overridevirtual

Reimplemented from flutter::ExternalViewEmbedder.

Definition at line 312 of file external_view_embedder.cc.

                                           {
  DestroySurfaces();
}

---

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

• shell/platform/android/external_view_embedder/external_view_embedder.h
• shell/platform/android/external_view_embedder/external_view_embedder.cc