[Android] update fallback and rendering state to combine impeller + android backend.

common/settings.h

@@ -22,6 +22,14 @@
 
 namespace flutter {
 
+// The combination of targeted graphics API and Impeller support.
+enum class AndroidRenderingAPI {
+  kSoftware,
+  kImpellerOpenGLES,
+  kImpellerVulkan,
+  kSkiaOpenGLES
+};
+
 class FrameTiming {
  public:
   enum Phase {
@@ -221,8 +229,12 @@ struct Settings {
   bool enable_impeller = false;
 #endif
 
-  // Requests a particular backend to be used (ex "opengles" or "vulkan")
-  std::optional<std::string> impeller_backend;
+  // The selected Android rendering API.
+  AndroidRenderingAPI android_rendering_api =
+      AndroidRenderingAPI::kSkiaOpenGLES;
+
+  // Requests a specific rendering backend.
+  std::optional<std::string> requested_rendering_backend;
 
   // Enable Vulkan validation on backends that support it. The validation layers
   // must be available to the application.

fml/message_loop.h

@@ -27,7 +27,6 @@ class MessageLoopImpl;
 /// \see fml::Wakeable
 class MessageLoop {
  public:
-  FML_EMBEDDER_ONLY
   static MessageLoop& GetCurrent();
 
   void Run();

shell/common/switches.cc

@@ -459,7 +459,7 @@ Settings SettingsFromCommandLine(const fml::CommandLine& command_line) {
     if (command_line.GetOptionValue(FlagForSwitch(Switch::ImpellerBackend),
                                     &impeller_backend_value)) {
       if (!impeller_backend_value.empty()) {
-        settings.impeller_backend = impeller_backend_value;
+        settings.requested_rendering_backend = impeller_backend_value;
       }
     }
   }

shell/platform/android/android_context_gl_impeller.cc

@@ -91,7 +91,7 @@ static std::shared_ptr<impeller::Context> CreateImpellerContext(
 AndroidContextGLImpeller::AndroidContextGLImpeller(
     std::unique_ptr<impeller::egl::Display> display,
     bool enable_gpu_tracing)
-    : AndroidContext(AndroidRenderingAPI::kOpenGLES),
+    : AndroidContext(AndroidRenderingAPI::kImpellerOpenGLES),
       reactor_worker_(std::shared_ptr<ReactorWorker>(new ReactorWorker())),
       display_(std::move(display)) {
   if (!display_ || !display_->IsValid()) {

shell/platform/android/android_context_gl_skia.cc

@@ -65,11 +65,10 @@ static bool TeardownContext(EGLDisplay display, EGLContext context) {
 }
 
 AndroidContextGLSkia::AndroidContextGLSkia(
-    AndroidRenderingAPI rendering_api,
     fml::RefPtr<AndroidEnvironmentGL> environment,
     const TaskRunners& task_runners,
     uint8_t msaa_samples)
-    : AndroidContext(AndroidRenderingAPI::kOpenGLES),
+    : AndroidContext(AndroidRenderingAPI::kSkiaOpenGLES),
       environment_(std::move(environment)),
       task_runners_(task_runners) {
   if (!environment_->IsValid()) {

shell/platform/android/android_context_gl_skia.h

@@ -27,8 +27,7 @@ class AndroidEGLSurface;
 ///
 class AndroidContextGLSkia : public AndroidContext {
  public:
-  AndroidContextGLSkia(AndroidRenderingAPI rendering_api,
-                       fml::RefPtr<AndroidEnvironmentGL> environment,
+  AndroidContextGLSkia(fml::RefPtr<AndroidEnvironmentGL> environment,
                        const TaskRunners& taskRunners,
                        uint8_t msaa_samples);
 

shell/platform/android/android_context_gl_unittests.cc

@@ -104,8 +104,8 @@ TEST(AndroidContextGl, Create) {
       thread_label, ThreadHost::Type::kUi | ThreadHost::Type::kRaster |
                         ThreadHost::Type::kIo));
   TaskRunners task_runners = MakeTaskRunners(thread_label, thread_host);
-  auto context = std::make_unique<AndroidContextGLSkia>(
-      AndroidRenderingAPI::kOpenGLES, environment, task_runners, 0);
+  auto context =
+      std::make_unique<AndroidContextGLSkia>(environment, task_runners, 0);
   context->SetMainSkiaContext(main_context);
   EXPECT_NE(context.get(), nullptr);
   context.reset();
@@ -115,7 +115,7 @@ TEST(AndroidContextGl, Create) {
 TEST(AndroidContextGl, CreateImpeller) {
   auto impeller_context = std::make_shared<TestImpellerContext>();
   auto android_context = std::make_unique<TestAndroidContext>(
-      impeller_context, AndroidRenderingAPI::kOpenGLES);
+      impeller_context, AndroidRenderingAPI::kImpellerOpenGLES);
   EXPECT_FALSE(impeller_context->did_shutdown);
 
   android_context.reset();
@@ -136,8 +136,8 @@ TEST(AndroidContextGl, CreateSingleThread) {
   TaskRunners task_runners =
       TaskRunners(thread_label, platform_runner, platform_runner,
                   platform_runner, platform_runner);
-  auto context = std::make_unique<AndroidContextGLSkia>(
-      AndroidRenderingAPI::kOpenGLES, environment, task_runners, 0);
+  auto context =
+      std::make_unique<AndroidContextGLSkia>(environment, task_runners, 0);
   context->SetMainSkiaContext(main_context);
   EXPECT_NE(context.get(), nullptr);
   context.reset();
@@ -155,8 +155,8 @@ TEST(AndroidSurfaceGL, CreateSnapshopSurfaceWhenOnscreenSurfaceIsNotNull) {
       thread_label, ThreadHost::Type::kUi | ThreadHost::Type::kRaster |
                         ThreadHost::Type::kIo));
   TaskRunners task_runners = MakeTaskRunners(thread_label, thread_host);
-  auto android_context = std::make_shared<AndroidContextGLSkia>(
-      AndroidRenderingAPI::kOpenGLES, environment, task_runners, 0);
+  auto android_context =
+      std::make_shared<AndroidContextGLSkia>(environment, task_runners, 0);
   auto android_surface =
       std::make_unique<AndroidSurfaceGLSkia>(android_context);
   auto window = fml::MakeRefCounted<AndroidNativeWindow>(
@@ -182,8 +182,8 @@ TEST(AndroidSurfaceGL, CreateSnapshopSurfaceWhenOnscreenSurfaceIsNull) {
 
   ThreadHost thread_host(host_config);
   TaskRunners task_runners = MakeTaskRunners(thread_label, thread_host);
-  auto android_context = std::make_shared<AndroidContextGLSkia>(
-      AndroidRenderingAPI::kOpenGLES, environment, task_runners, 0);
+  auto android_context =
+      std::make_shared<AndroidContextGLSkia>(environment, task_runners, 0);
   auto android_surface =
       std::make_unique<AndroidSurfaceGLSkia>(android_context);
   EXPECT_EQ(android_surface->GetOnscreenSurface(), nullptr);
@@ -204,8 +204,8 @@ TEST(AndroidContextGl, DISABLED_MSAAx4) {
       thread_label, ThreadHost::Type::kUi | ThreadHost::Type::kRaster |
                         ThreadHost::Type::kIo));
   TaskRunners task_runners = MakeTaskRunners(thread_label, thread_host);
-  auto context = std::make_unique<AndroidContextGLSkia>(
-      AndroidRenderingAPI::kOpenGLES, environment, task_runners, 4);
+  auto context =
+      std::make_unique<AndroidContextGLSkia>(environment, task_runners, 4);
   context->SetMainSkiaContext(main_context);
 
   EGLint sample_count;
@@ -226,8 +226,8 @@ TEST(AndroidContextGl, EnsureMakeCurrentChecksCurrentContextStatus) {
       thread_label, ThreadHost::Type::kUi | ThreadHost::Type::kRaster |
                         ThreadHost::Type::kIo));
   TaskRunners task_runners = MakeTaskRunners(thread_label, thread_host);
-  auto context = std::make_unique<AndroidContextGLSkia>(
-      AndroidRenderingAPI::kOpenGLES, environment, task_runners, 0);
+  auto context =
+      std::make_unique<AndroidContextGLSkia>(environment, task_runners, 0);
 
   auto pbuffer_surface = context->CreatePbufferSurface();
   auto status = pbuffer_surface->MakeCurrent();

shell/platform/android/android_context_vulkan_impeller.cc

@@ -19,7 +19,8 @@ namespace flutter {
 static std::shared_ptr<impeller::Context> CreateImpellerContext(
     const fml::RefPtr<fml::NativeLibrary>& vulkan_dylib,
     bool enable_vulkan_validation,
-    bool enable_gpu_tracing) {
+    bool enable_gpu_tracing,
+    bool quiet) {
   if (!vulkan_dylib) {
     VALIDATION_LOG << "Could not open the Vulkan dylib.";
     return nullptr;
@@ -57,24 +58,27 @@ static std::shared_ptr<impeller::Context> CreateImpellerContext(
 
   auto context = impeller::ContextVK::Create(std::move(settings));
 
-  if (context && impeller::CapabilitiesVK::Cast(*context->GetCapabilities())
-                     .AreValidationsEnabled()) {
-    FML_LOG(IMPORTANT) << "Using the Impeller rendering backend (Vulkan with "
-                          "Validation Layers).";
-  } else {
-    FML_LOG(IMPORTANT) << "Using the Impeller rendering backend (Vulkan).";
+  if (!quiet) {
+    if (context && impeller::CapabilitiesVK::Cast(*context->GetCapabilities())
+                       .AreValidationsEnabled()) {
+      FML_LOG(IMPORTANT) << "Using the Impeller rendering backend (Vulkan with "
+                            "Validation Layers).";
+    } else {
+      FML_LOG(IMPORTANT) << "Using the Impeller rendering backend (Vulkan).";
+    }
   }
 
   return context;
 }
 
 AndroidContextVulkanImpeller::AndroidContextVulkanImpeller(
     bool enable_validation,
-    bool enable_gpu_tracing)
-    : AndroidContext(AndroidRenderingAPI::kVulkan),
+    bool enable_gpu_tracing,
+    bool quiet)
+    : AndroidContext(AndroidRenderingAPI::kImpellerVulkan),
       vulkan_dylib_(fml::NativeLibrary::Create("libvulkan.so")) {
   auto impeller_context = CreateImpellerContext(
-      vulkan_dylib_, enable_validation, enable_gpu_tracing);
+      vulkan_dylib_, enable_validation, enable_gpu_tracing, quiet);
   SetImpellerContext(impeller_context);
   is_valid_ = !!impeller_context;
 }

shell/platform/android/android_context_vulkan_impeller.h

@@ -14,7 +14,9 @@ namespace flutter {
 
 class AndroidContextVulkanImpeller : public AndroidContext {
  public:
-  AndroidContextVulkanImpeller(bool enable_validation, bool enable_gpu_tracing);
+  AndroidContextVulkanImpeller(bool enable_validation,
+                               bool enable_gpu_tracing,
+                               bool quiet = false);
 
   ~AndroidContextVulkanImpeller();
 

shell/platform/android/context/BUILD.gn

@@ -14,6 +14,7 @@ source_set("context") {
   public_configs = [ "//flutter:config" ]
 
   deps = [
+    "//flutter/common",
     "//flutter/fml",
     "//flutter/impeller/renderer",
     "//flutter/skia",

shell/platform/android/context/android_context.h

@@ -5,22 +5,14 @@
 #ifndef FLUTTER_SHELL_PLATFORM_ANDROID_CONTEXT_ANDROID_CONTEXT_H_
 #define FLUTTER_SHELL_PLATFORM_ANDROID_CONTEXT_ANDROID_CONTEXT_H_
 
+#include "common/settings.h"
 #include "flutter/fml/macros.h"
 #include "flutter/fml/task_runner.h"
 #include "flutter/impeller/renderer/context.h"
 #include "third_party/skia/include/gpu/GrDirectContext.h"
 
 namespace flutter {
 
-enum class AndroidRenderingAPI {
-  kSoftware,
-  kOpenGLES,
-  kVulkan,
-  /// @brief Attempt to create a Vulkan surface, if that fails then fall back
-  /// to GLES.
-  kAutoselect,
-};
-
 //------------------------------------------------------------------------------
 /// @brief      Holds state that is shared across Android surfaces.
 ///

shell/platform/android/flutter_main.cc

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "common/settings.h"
+#include "impeller/base/validation.h"
 #define FML_USED_ON_EMBEDDER
 
 #include "flutter/shell/platform/android/flutter_main.h"
@@ -13,6 +15,7 @@
 
 #include "flutter/fml/command_line.h"
 #include "flutter/fml/file.h"
+#include "flutter/fml/logging.h"
 #include "flutter/fml/macros.h"
 #include "flutter/fml/message_loop.h"
 #include "flutter/fml/native_library.h"
@@ -25,11 +28,14 @@
 #include "flutter/runtime/dart_vm.h"
 #include "flutter/shell/common/shell.h"
 #include "flutter/shell/common/switches.h"
+#include "flutter/shell/platform/android/android_context_vulkan_impeller.h"
 #include "third_party/dart/runtime/include/dart_tools_api.h"
 #include "txt/platform.h"
 
 namespace flutter {
 
+constexpr int kMinimumAndroidApiLevelForVulkan = 29;
+
 extern "C" {
 #if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG
 // Used for debugging dart:* sources.
@@ -91,6 +97,18 @@ void FlutterMain::Init(JNIEnv* env,
     }
   }
 
+  settings.android_rendering_api = SelectedRenderingAPI(settings);
+  switch (settings.android_rendering_api) {
+    case AndroidRenderingAPI::kSoftware:
+    case AndroidRenderingAPI::kSkiaOpenGLES:
+      settings.enable_impeller = false;
+      break;
+    case AndroidRenderingAPI::kImpellerOpenGLES:
+    case AndroidRenderingAPI::kImpellerVulkan:
+      settings.enable_impeller = true;
+      break;
+  }
+
 #if FLUTTER_RELEASE
   // On most platforms the timeline is always disabled in release mode.
   // On Android, enable it in release mode only when using systrace.
@@ -211,4 +229,53 @@ bool FlutterMain::Register(JNIEnv* env) {
   return env->RegisterNatives(clazz, methods, fml::size(methods)) == 0;
 }
 
+// static
+AndroidRenderingAPI FlutterMain::SelectedRenderingAPI(
+    const flutter::Settings& settings) {
+  if (settings.enable_software_rendering) {
+    FML_CHECK(!settings.enable_impeller)
+        << "Impeller does not support software rendering. Either disable "
+           "software rendering or disable impeller.";
+    return AndroidRenderingAPI::kSoftware;
+  }
+  // Debug/Profile only functionality for testing a specific
+  // backend configuration.
+#ifndef FLUTTER_RELEASE
+  if (settings.requested_rendering_backend == "opengles" &
+      settings.enable_impeller) {
+    return AndroidRenderingAPI::kImpellerOpenGLES;
+  }
+  if (settings.requested_rendering_backend == "vulkan" &&
+      settings.enable_impeller) {
+    return AndroidRenderingAPI::kImpellerVulkan;
+  }
+#endif
+
+  if (settings.enable_impeller) {
+    // Vulkan must only be used on API level 29+, as older API levels do not
+    // have requisite features to support platform views.
+    //
+    // Even if this check returns true, Impeller may determine it cannot use
+    // Vulkan for some other reason, such as a missing required extension or
+    // feature.
+    int api_level = android_get_device_api_level();
+    if (api_level < kMinimumAndroidApiLevelForVulkan) {
+      return AndroidRenderingAPI::kImpellerOpenGLES;
+    }
+    // Determine if Vulkan is supported by creating a Vulkan context and
+    // checking if it is valid.
+    impeller::ScopedValidationDisable disable_validation;
+    auto vulkan_backend = std::make_unique<AndroidContextVulkanImpeller>(
+        /*enable_vulkan_validation=*/false,
+        /*enable_vulkan_gpu_tracing=*/false,
+        /*quiet=*/true);
+    if (!vulkan_backend->IsValid()) {
+      return AndroidRenderingAPI::kImpellerOpenGLES;
+    }
+    return AndroidRenderingAPI::kImpellerVulkan;
+  }
+
+  return AndroidRenderingAPI::kSkiaOpenGLES;
+}
+
 }  // namespace flutter

shell/platform/android/flutter_main.h

@@ -23,6 +23,9 @@ class FlutterMain {
 
   const flutter::Settings& GetSettings() const;
 
+  static AndroidRenderingAPI SelectedRenderingAPI(
+      const flutter::Settings& settings);
+
  private:
   const flutter::Settings settings_;
   DartServiceIsolate::CallbackHandle vm_service_uri_callback_ = 0;