flutter::AndroidContextGLImpeller Class Reference

#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)
	~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 14 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
	)

Definition at line 108 of file android_context_gl_impeller.cc.

    : AndroidContext(AndroidRenderingAPI::kImpellerOpenGLES),
      reactor_worker_(std::shared_ptr<ReactorWorker>(new ReactorWorker())),
      display_(std::move(display)) {
  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);
 
  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 240 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 262 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 218 of file android_context_gl_impeller.cc.

                                             {
  return is_valid_;
}

OnscreenContextClearCurrent()

bool flutter::AndroidContextGLImpeller::OnscreenContextClearCurrent

(

)

Definition at line 253 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 244 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 266 of file android_context_gl_impeller.cc.

                                                                 {
  return AndroidRenderingAPI::kImpellerOpenGLES;
}

References flutter::kImpellerOpenGLES.

ResourceContextClearCurrent()

bool flutter::AndroidContextGLImpeller::ResourceContextClearCurrent

(

)

Definition at line 222 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 230 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