#include <android_context_gl_impeller.h>

Inheritance diagram for flutter::AndroidContextGLImpeller:

Classes
class	ReactorWorker

Public Member Functions
	AndroidContextGLImpeller (std::unique_ptr< impeller::egl::Display > display, bool enable_gpu_tracing, std::shared_ptr< fml::BasicTaskRunner > io_task_runner)

	~AndroidContextGLImpeller ()

bool	IsValid () const override

AndroidRenderingAPI	RenderingApi () const override

bool	ResourceContextMakeCurrent (impeller::egl::Surface *offscreen_surface)

bool	ResourceContextClearCurrent ()

std::unique_ptr< impeller::egl::Surface >	CreateOffscreenSurface ()

bool	OnscreenContextMakeCurrent (impeller::egl::Surface *onscreen_surface)

bool	OnscreenContextClearCurrent ()

std::unique_ptr< impeller::egl::Surface >	CreateOnscreenSurface (EGLNativeWindowType window)

Public Member Functions inherited from flutter::AndroidContext
	AndroidContext (AndroidRenderingAPI rendering_api)

virtual	~AndroidContext ()

virtual bool	IsDynamicSelection () const

void	SetMainSkiaContext (const sk_sp< GrDirectContext > &main_context)
	Setter for the Skia context to be used by subsequent AndroidSurfaces.

sk_sp< GrDirectContext >	GetMainSkiaContext () const
	Accessor for the Skia context associated with AndroidSurfaces and the raster thread.

virtual std::shared_ptr< impeller::Context >	GetImpellerContext () const
	Accessor for the Impeller context associated with AndroidSurfaces and the raster thread.

virtual void	SetupImpellerContext ()
	Perform deferred setup for the impeller Context.

Additional Inherited Members
Protected Member Functions inherited from flutter::AndroidContext
void	SetImpellerContext (const std::shared_ptr< impeller::Context > &impeller_context)

Detailed Description

Definition at line 15 of file android_context_gl_impeller.h.

Constructor & Destructor Documentation

◆ AndroidContextGLImpeller()

flutter::AndroidContextGLImpeller::AndroidContextGLImpeller	(	std::unique_ptr< impeller::egl::Display >	display,
		bool	enable_gpu_tracing,
		std::shared_ptr< fml::BasicTaskRunner >	io_task_runner
	)

Definition at line 109 of file android_context_gl_impeller.cc.

    : AndroidContext(AndroidRenderingAPI::kImpellerOpenGLES),
      reactor_worker_(std::shared_ptr<ReactorWorker>(new ReactorWorker())),
      display_(std::move(display)),
      io_task_runner_(std::move(io_task_runner)) {
  if (!display_ || !display_->IsValid()) {
    FML_LOG(ERROR) << "Could not create context with invalid EGL display.";
    return;
  }
 
  impeller::egl::ConfigDescriptor desc;
  desc.api = impeller::egl::API::kOpenGLES3;
  desc.color_format = impeller::egl::ColorFormat::kRGBA8888;
  desc.depth_bits = impeller::egl::DepthBits::kTwentyFour;
  desc.stencil_bits = impeller::egl::StencilBits::kEight;
  desc.samples = impeller::egl::Samples::kFour;
 
  desc.surface_type = impeller::egl::SurfaceType::kWindow;
  std::unique_ptr<impeller::egl::Config> onscreen_config =
      display_->ChooseConfig(desc);
 
  if (!onscreen_config) {
    desc.api = impeller::egl::API::kOpenGLES2;
    onscreen_config = display_->ChooseConfig(desc);
  }
 
  if (!onscreen_config) {
    // Fallback for Android emulator.
    desc.samples = impeller::egl::Samples::kOne;
    onscreen_config = display_->ChooseConfig(desc);
    if (onscreen_config) {
      FML_LOG(INFO) << "Warning: This device doesn't support MSAA for onscreen "
                       "framebuffers. Falling back to a single sample.";
    } else {
      FML_LOG(ERROR) << "Could not choose onscreen config.";
      return;
    }
  }
 
  desc.surface_type = impeller::egl::SurfaceType::kPBuffer;
  auto offscreen_config = display_->ChooseConfig(desc);
  if (!offscreen_config) {
    FML_LOG(ERROR) << "Could not choose offscreen config.";
    return;
  }
 
  auto onscreen_context = display_->CreateContext(*onscreen_config, nullptr);
  if (!onscreen_context) {
    FML_LOG(ERROR) << "Could not create onscreen context.";
    return;
  }
 
  auto offscreen_context =
      display_->CreateContext(*offscreen_config, onscreen_context.get());
  if (!offscreen_context) {
    FML_LOG(ERROR) << "Could not create offscreen context.";
    return;
  }
 
  // Creating the impeller::Context requires a current context, which requires
  // some surface.
  auto offscreen_surface =
      display_->CreatePixelBufferSurface(*offscreen_config, 1u, 1u);
  if (!offscreen_context->MakeCurrent(*offscreen_surface)) {
    FML_LOG(ERROR) << "Could not make offscreen context current.";
    return;
  }
 
  auto impeller_context = CreateImpellerContext(
      reactor_worker_, enable_gpu_tracing, io_task_runner_);
 
  if (!impeller_context) {
    FML_LOG(ERROR) << "Could not create Impeller context.";
    return;
  }
 
  if (!offscreen_context->ClearCurrent()) {
    FML_LOG(ERROR) << "Could not clear offscreen context.";
    return;
  }
  // Setup context listeners.
  impeller::egl::Context::LifecycleListener listener =
      [worker =
           reactor_worker_](impeller::egl ::Context::LifecycleEvent event) {
        switch (event) {
          case impeller::egl::Context::LifecycleEvent::kDidMakeCurrent:
            worker->SetReactionsAllowedOnCurrentThread(true);
            break;
          case impeller::egl::Context::LifecycleEvent::kWillClearCurrent:
            worker->SetReactionsAllowedOnCurrentThread(false);
            break;
        }
      };
  if (!onscreen_context->AddLifecycleListener(listener).has_value() ||
      !offscreen_context->AddLifecycleListener(listener).has_value()) {
    FML_LOG(ERROR) << "Could not add lifecycle listeners";
  }
 
  onscreen_config_ = std::move(onscreen_config);
  offscreen_config_ = std::move(offscreen_config);
  onscreen_context_ = std::move(onscreen_context);
  offscreen_context_ = std::move(offscreen_context);
  SetImpellerContext(impeller_context);
 
  is_valid_ = true;
}

References impeller::egl::ConfigDescriptor::api, impeller::egl::ConfigDescriptor::color_format, CreateImpellerContext(), impeller::egl::ConfigDescriptor::depth_bits, FML_LOG, impeller::egl::Context::kDidMakeCurrent, impeller::egl::kEight, impeller::egl::kFour, impeller::egl::kOne, impeller::egl::kOpenGLES2, impeller::egl::kOpenGLES3, impeller::egl::kPBuffer, impeller::egl::kRGBA8888, impeller::egl::kTwentyFour, impeller::egl::Context::kWillClearCurrent, impeller::egl::kWindow, impeller::egl::ConfigDescriptor::samples, flutter::AndroidContext::SetImpellerContext(), impeller::egl::ConfigDescriptor::stencil_bits, and impeller::egl::ConfigDescriptor::surface_type.

◆ ~AndroidContextGLImpeller()

flutter::AndroidContextGLImpeller::~AndroidContextGLImpeller ( )

default

Member Function Documentation

◆ CreateOffscreenSurface()

std::unique_ptr< impeller::egl::Surface > flutter::AndroidContextGLImpeller::CreateOffscreenSurface ( )

Definition at line 243 of file android_context_gl_impeller.cc.

                                                 {
  return display_->CreatePixelBufferSurface(*offscreen_config_, 1u, 1u);
}

◆ CreateOnscreenSurface()

std::unique_ptr< impeller::egl::Surface > flutter::AndroidContextGLImpeller::CreateOnscreenSurface ( EGLNativeWindowType window )

Definition at line 265 of file android_context_gl_impeller.cc.

                                                                          {
  return display_->CreateWindowSurface(*onscreen_config_, window);
}

References window.

◆ IsValid()

bool flutter::AndroidContextGLImpeller::IsValid ( ) const

overridevirtual

Reimplemented from flutter::AndroidContext.

Definition at line 221 of file android_context_gl_impeller.cc.

                                             {
  return is_valid_;
}

◆ OnscreenContextClearCurrent()

bool flutter::AndroidContextGLImpeller::OnscreenContextClearCurrent ( )

Definition at line 256 of file android_context_gl_impeller.cc.

                                                           {
  if (!onscreen_context_) {
    return false;
  }
 
  return onscreen_context_->ClearCurrent();
}

◆ OnscreenContextMakeCurrent()

bool flutter::AndroidContextGLImpeller::OnscreenContextMakeCurrent ( impeller::egl::Surface * onscreen_surface )

Definition at line 247 of file android_context_gl_impeller.cc.

                                          {
  if (!onscreen_surface || !onscreen_context_) {
    return false;
  }
 
  return onscreen_context_->MakeCurrent(*onscreen_surface);
}

◆ RenderingApi()

AndroidRenderingAPI flutter::AndroidContextGLImpeller::RenderingApi ( ) const

overridevirtual

Reimplemented from flutter::AndroidContext.

Definition at line 269 of file android_context_gl_impeller.cc.

                                                                 {
  return AndroidRenderingAPI::kImpellerOpenGLES;
}

References flutter::kImpellerOpenGLES.

◆ ResourceContextClearCurrent()

bool flutter::AndroidContextGLImpeller::ResourceContextClearCurrent ( )

Definition at line 225 of file android_context_gl_impeller.cc.

                                                           {
  if (!offscreen_context_) {
    return false;
  }
 
  return offscreen_context_->ClearCurrent();
}

◆ ResourceContextMakeCurrent()

bool flutter::AndroidContextGLImpeller::ResourceContextMakeCurrent ( impeller::egl::Surface * offscreen_surface )

Definition at line 233 of file android_context_gl_impeller.cc.

                                           {
  if (!offscreen_context_ || !offscreen_surface) {
    return false;
  }
 
  return offscreen_context_->MakeCurrent(*offscreen_surface);
}

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

shell/platform/android/android_context_gl_impeller.h
shell/platform/android/android_context_gl_impeller.cc

Classes

Public Member Functions

Additional Inherited Members