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
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 ()
AndroidRenderingAPI	RenderingApi () 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.
std::shared_ptr< impeller::Context >	GetImpellerContext () const
	Accessor for the Impeller context associated with AndroidSurfaces and the raster thread.

Additional Inherited Members
Protected Member Functions inherited from flutter::AndroidContext
void	SetImpellerContext (const std::shared_ptr< impeller::Context > &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 91 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_DLOG(ERROR) << "Could not create context with invalid EGL display.";
    return;
  }
 
  impeller::egl::ConfigDescriptor desc;
  desc.api = impeller::egl::API::kOpenGLES2;
  desc.color_format = impeller::egl::ColorFormat::kRGBA8888;
  desc.depth_bits = impeller::egl::DepthBits::kZero;
  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) {
    // 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_DLOG(ERROR) << "Could not choose onscreen config.";
      return;
    }
  }
 
  desc.surface_type = impeller::egl::SurfaceType::kPBuffer;
  auto offscreen_config = display_->ChooseConfig(desc);
  if (!offscreen_config) {
    FML_DLOG(ERROR) << "Could not choose offscreen config.";
    return;
  }
 
  auto onscreen_context = display_->CreateContext(*onscreen_config, nullptr);
  if (!onscreen_context) {
    FML_DLOG(ERROR) << "Could not create onscreen context.";
    return;
  }
 
  auto offscreen_context =
      display_->CreateContext(*offscreen_config, onscreen_context.get());
  if (!offscreen_context) {
    FML_DLOG(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_DLOG(ERROR) << "Could not make offscreen context current.";
    return;
  }
 
  auto impeller_context =
      CreateImpellerContext(reactor_worker_, enable_gpu_tracing);
 
  if (!impeller_context) {
    FML_DLOG(ERROR) << "Could not create Impeller context.";
    return;
  }
 
  if (!offscreen_context->ClearCurrent()) {
    FML_DLOG(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_DLOG(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;
}

~AndroidContextGLImpeller()

flutter::AndroidContextGLImpeller::~AndroidContextGLImpeller ( )

default

Member Function Documentation

CreateOffscreenSurface()

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

(

)

Definition at line 217 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 239 of file android_context_gl_impeller.cc.

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

IsValid()

bool flutter::AndroidContextGLImpeller::IsValid ( ) const

overridevirtual

Reimplemented from flutter::AndroidContext.

Definition at line 195 of file android_context_gl_impeller.cc.

                                             {
  return is_valid_;
}

OnscreenContextClearCurrent()

bool flutter::AndroidContextGLImpeller::OnscreenContextClearCurrent

(

)

Definition at line 230 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 221 of file android_context_gl_impeller.cc.

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

ResourceContextClearCurrent()

bool flutter::AndroidContextGLImpeller::ResourceContextClearCurrent

(

)

Definition at line 199 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 207 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