flutter::AndroidShellHolder Class Reference

This is the Android owner of the core engine Shell. More...

#include <android_shell_holder.h>

Public Member Functions
	AndroidShellHolder (const flutter::Settings &settings, std::shared_ptr< PlatformViewAndroidJNI > jni_facade)
	~AndroidShellHolder ()
bool	IsValid () const
std::unique_ptr< AndroidShellHolder >	Spawn (std::shared_ptr< PlatformViewAndroidJNI > jni_facade, const std::string &entrypoint, const std::string &libraryUrl, const std::string &initial_route, const std::vector< std::string > &entrypoint_args) const
	This is a factory for a derived AndroidShellHolder from an existing AndroidShellHolder.
void	Launch (std::unique_ptr< APKAssetProvider > apk_asset_provider, const std::string &entrypoint, const std::string &libraryUrl, const std::vector< std::string > &entrypoint_args)
const flutter::Settings &	GetSettings () const
fml::WeakPtr< PlatformViewAndroid >	GetPlatformView ()
Rasterizer::Screenshot	Screenshot (Rasterizer::ScreenshotType type, bool base64_encode)
void	NotifyLowMemoryWarning ()
const std::shared_ptr< PlatformMessageHandler > &	GetPlatformMessageHandler () const
void	UpdateDisplayMetrics ()

Detailed Description

This is the Android owner of the core engine Shell.

This is the top orchestrator class on the C++ side for the Android embedding. It corresponds to a FlutterEngine on the Java side. This class is in C++ because the Shell is in C++ and an Android orchestrator needs to exist to compose it with other Android specific C++ components such as the PlatformViewAndroid. This composition of many-to-one C++ components would be difficult to do through JNI whereas a FlutterEngine and AndroidShellHolder has a 1:1 relationship.

Technically, the FlutterJNI class owns this AndroidShellHolder class instance, but the FlutterJNI class is meant to be mostly static and has minimal state to perform the C++ pointer <-> Java class instance translation.

Definition at line 42 of file android_shell_holder.h.

Constructor & Destructor Documentation

AndroidShellHolder()

flutter::AndroidShellHolder::AndroidShellHolder	(	const flutter::Settings &	settings,
		std::shared_ptr< PlatformViewAndroidJNI >	jni_facade
	)

Definition at line 85 of file android_shell_holder.cc.

    : settings_(settings), jni_facade_(jni_facade) {
  static size_t thread_host_count = 1;
  auto thread_label = std::to_string(thread_host_count++);
 
  auto mask =
      ThreadHost::Type::kUi | ThreadHost::Type::kRaster | ThreadHost::Type::kIo;
 
  flutter::ThreadHost::ThreadHostConfig host_config(
      thread_label, mask, AndroidPlatformThreadConfigSetter);
  host_config.ui_config = fml::Thread::ThreadConfig(
      flutter::ThreadHost::ThreadHostConfig::MakeThreadName(
          flutter::ThreadHost::Type::kUi, thread_label),
      fml::Thread::ThreadPriority::kDisplay);
  host_config.raster_config = fml::Thread::ThreadConfig(
      flutter::ThreadHost::ThreadHostConfig::MakeThreadName(
          flutter::ThreadHost::Type::kRaster, thread_label),
      fml::Thread::ThreadPriority::kRaster);
  host_config.io_config = fml::Thread::ThreadConfig(
      flutter::ThreadHost::ThreadHostConfig::MakeThreadName(
          flutter::ThreadHost::Type::kIo, thread_label),
      fml::Thread::ThreadPriority::kNormal);
 
  thread_host_ = std::make_shared<ThreadHost>(host_config);
 
  fml::WeakPtr<PlatformViewAndroid> weak_platform_view;
  Shell::CreateCallback<PlatformView> on_create_platform_view =
      [&jni_facade, &weak_platform_view](Shell& shell) {
        std::unique_ptr<PlatformViewAndroid> platform_view_android;
        platform_view_android = std::make_unique<PlatformViewAndroid>(
            shell,                   // delegate
            shell.GetTaskRunners(),  // task runners
            jni_facade,              // JNI interop
            shell.GetSettings()
                .enable_software_rendering,   // use software rendering
            shell.GetSettings().msaa_samples  // msaa sample count
        );
        weak_platform_view = platform_view_android->GetWeakPtr();
        return platform_view_android;
      };
 
  Shell::CreateCallback<Rasterizer> on_create_rasterizer = [](Shell& shell) {
    return std::make_unique<Rasterizer>(shell);
  };
 
  // The current thread will be used as the platform thread. Ensure that the
  // message loop is initialized.
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  fml::RefPtr<fml::TaskRunner> raster_runner;
  fml::RefPtr<fml::TaskRunner> ui_runner;
  fml::RefPtr<fml::TaskRunner> io_runner;
  fml::RefPtr<fml::TaskRunner> platform_runner =
      fml::MessageLoop::GetCurrent().GetTaskRunner();
  raster_runner = thread_host_->raster_thread->GetTaskRunner();
  ui_runner = thread_host_->ui_thread->GetTaskRunner();
  io_runner = thread_host_->io_thread->GetTaskRunner();
 
  flutter::TaskRunners task_runners(thread_label,     // label
                                    platform_runner,  // platform
                                    raster_runner,    // raster
                                    ui_runner,        // ui
                                    io_runner         // io
  );
 
  shell_ =
      Shell::Create(GetDefaultPlatformData(),  // window data
                    task_runners,              // task runners
                    settings_,                 // settings
                    on_create_platform_view,   // platform view create callback
                    on_create_rasterizer       // rasterizer create callback
      );
 
  if (shell_) {
    shell_->GetDartVM()->GetConcurrentMessageLoop()->PostTaskToAllWorkers([]() {
      if (::setpriority(PRIO_PROCESS, gettid(), 1) != 0) {
        FML_LOG(ERROR) << "Failed to set Workers task runner priority";
      }
    });
 
    shell_->RegisterImageDecoder(
        [runner = task_runners.GetIOTaskRunner()](sk_sp<SkData> buffer) {
          return AndroidImageGenerator::MakeFromData(std::move(buffer), runner);
        },
        -1);
    FML_DLOG(INFO) << "Registered Android SDK image decoder (API level 28+)";
  }
 
  platform_view_ = weak_platform_view;
  FML_DCHECK(platform_view_);
  is_valid_ = shell_ != nullptr;
}

~AndroidShellHolder()

flutter::AndroidShellHolder::~AndroidShellHolder

(

)

Definition at line 200 of file android_shell_holder.cc.

                                        {
  shell_.reset();
  thread_host_.reset();
}

Member Function Documentation

GetPlatformMessageHandler()

const std::shared_ptr< PlatformMessageHandler > & flutter::AndroidShellHolder::GetPlatformMessageHandler ( ) const

inline

Definition at line 101 of file android_shell_holder.h.

            {
    return shell_->GetPlatformMessageHandler();
  }

GetPlatformView()

fml::WeakPtr< PlatformViewAndroid > flutter::AndroidShellHolder::GetPlatformView

(

)

Definition at line 305 of file android_shell_holder.cc.

                                                                    {
  FML_DCHECK(platform_view_);
  return platform_view_;
}

GetSettings()

const flutter::Settings & flutter::AndroidShellHolder::GetSettings

(

)

const

Definition at line 209 of file android_shell_holder.cc.

                                                             {
  return settings_;
}

IsValid()

bool flutter::AndroidShellHolder::IsValid

(

)

const

Definition at line 205 of file android_shell_holder.cc.

                                       {
  return is_valid_;
}

Launch()

void flutter::AndroidShellHolder::Launch	(	std::unique_ptr< APKAssetProvider >	apk_asset_provider,
		const std::string &	entrypoint,
		const std::string &	libraryUrl,
		const std::vector< std::string > &	entrypoint_args
	)

Definition at line 277 of file android_shell_holder.cc.

                                                 {
  if (!IsValid()) {
    return;
  }
 
  apk_asset_provider_ = std::move(apk_asset_provider);
  auto config = BuildRunConfiguration(entrypoint, libraryUrl, entrypoint_args);
  if (!config) {
    return;
  }
  UpdateDisplayMetrics();
  shell_->RunEngine(std::move(config.value()));
}

NotifyLowMemoryWarning()

void flutter::AndroidShellHolder::NotifyLowMemoryWarning

(

)

Definition at line 310 of file android_shell_holder.cc.

                                                {
  FML_DCHECK(shell_);
  shell_->NotifyLowMemoryWarning();
}

Screenshot()

Rasterizer::Screenshot flutter::AndroidShellHolder::Screenshot	(	Rasterizer::ScreenshotType	type,
		bool	base64_encode
	)

Definition at line 295 of file android_shell_holder.cc.

                        {
  if (!IsValid()) {
    return {nullptr, SkISize::MakeEmpty(), "",
            Rasterizer::ScreenshotFormat::kUnknown};
  }
  return shell_->Screenshot(type, base64_encode);
}

Spawn()

std::unique_ptr< AndroidShellHolder > flutter::AndroidShellHolder::Spawn	(	std::shared_ptr< PlatformViewAndroidJNI >	jni_facade,
		const std::string &	entrypoint,
		const std::string &	libraryUrl,
		const std::string &	initial_route,
		const std::vector< std::string > &	entrypoint_args
	)		const

This is a factory for a derived AndroidShellHolder from an existing AndroidShellHolder.

Creates one Shell from another Shell where the created Shell takes the opportunity to share any internal components it can. This results is a Shell that has a smaller startup time cost and a smaller memory footprint than an Shell created with a Create function.

The new Shell is returned in a new AndroidShellHolder instance.

The new Shell's flutter::Settings cannot be changed from that of the initial Shell. The RunConfiguration subcomponent can be changed however in the spawned Shell to run a different entrypoint than the existing shell.

Since the AndroidShellHolder both binds downwards to a Shell and also upwards to JNI callbacks that the PlatformViewAndroid makes, the JNI instance holding this AndroidShellHolder should be created first to supply the jni_facade callback.

Parameters

[in]

jni_facade

this argument should be the JNI callback facade of a new JNI instance meant to hold this AndroidShellHolder.

Returns

A new AndroidShellHolder containing a new Shell. Returns nullptr when a new Shell can't be created.

Definition at line 213 of file android_shell_holder.cc.

                                                       {
  FML_DCHECK(shell_ && shell_->IsSetup())
      << "A new Shell can only be spawned "
         "if the current Shell is properly constructed";
 
  // Pull out the new PlatformViewAndroid from the new Shell to feed to it to
  // the new AndroidShellHolder.
  //
  // It's a weak pointer because it's owned by the Shell (which we're also)
  // making below. And the AndroidShellHolder then owns the Shell.
  fml::WeakPtr<PlatformViewAndroid> weak_platform_view;
 
  // Take out the old AndroidContext to reuse inside the PlatformViewAndroid
  // of the new Shell.
  PlatformViewAndroid* android_platform_view = platform_view_.get();
  // There's some indirection with platform_view_ being a weak pointer but
  // we just checked that the shell_ exists above and a valid shell is the
  // owner of the platform view so this weak pointer always exists.
  FML_DCHECK(android_platform_view);
  std::shared_ptr<flutter::AndroidContext> android_context =
      android_platform_view->GetAndroidContext();
  FML_DCHECK(android_context);
 
  // This is a synchronous call, so the captures don't have race checks.
  Shell::CreateCallback<PlatformView> on_create_platform_view =
      [&jni_facade, android_context, &weak_platform_view](Shell& shell) {
        std::unique_ptr<PlatformViewAndroid> platform_view_android;
        platform_view_android = std::make_unique<PlatformViewAndroid>(
            shell,                   // delegate
            shell.GetTaskRunners(),  // task runners
            jni_facade,              // JNI interop
            android_context          // Android context
        );
        weak_platform_view = platform_view_android->GetWeakPtr();
        return platform_view_android;
      };
 
  Shell::CreateCallback<Rasterizer> on_create_rasterizer = [](Shell& shell) {
    return std::make_unique<Rasterizer>(shell);
  };
 
  // TODO(xster): could be worth tracing this to investigate whether
  // the IsolateConfiguration could be cached somewhere.
  auto config = BuildRunConfiguration(entrypoint, libraryUrl, entrypoint_args);
  if (!config) {
    // If the RunConfiguration was null, the kernel blob wasn't readable.
    // Fail the whole thing.
    return nullptr;
  }
 
  std::unique_ptr<flutter::Shell> shell =
      shell_->Spawn(std::move(config.value()), initial_route,
                    on_create_platform_view, on_create_rasterizer);
 
  return std::unique_ptr<AndroidShellHolder>(new AndroidShellHolder(
      GetSettings(), jni_facade, thread_host_, std::move(shell),
      apk_asset_provider_->Clone(), weak_platform_view));
}

UpdateDisplayMetrics()

void flutter::AndroidShellHolder::UpdateDisplayMetrics

(

)

Definition at line 350 of file android_shell_holder.cc.

                                              {
  std::vector<std::unique_ptr<Display>> displays;
  displays.push_back(std::make_unique<AndroidDisplay>(jni_facade_));
  shell_->OnDisplayUpdates(std::move(displays));
}

---

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

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