update

com.unity.uiwidgets/Runtime/engine/UIWidgetsPanelWrapper.cs

 
 #if (!UNITY_EDITOR && UNITY_ANDROID )
     public partial class UIWidgetsPanelWrapper {
-        RenderTexture _renderTexture;
+        Texture _renderTexture;
-        public RenderTexture renderTexture {
+        public Texture renderTexture {
-            D.assert(_renderTexture == null);
-
-            var desc = new RenderTextureDescriptor(
-                width, height, RenderTextureFormat.ARGB32, 0) {
-                useMipMap = false,
-                autoGenerateMips = false,
-            };
-
-            _renderTexture = new RenderTexture(desc) {hideFlags = HideFlags.HideAndDontSave};
-            _renderTexture.Create();
+            // D.assert(_renderTexture == null);
+            //
+            // var desc = new RenderTextureDescriptor(
+            //     width, height, RenderTextureFormat.ARGB32, 0) {
+            //     useMipMap = false,
+            //     autoGenerateMips = false,
+            // };
+            //
+            // _renderTexture = new RenderTexture(desc) {hideFlags = HideFlags.HideAndDontSave};
+            // _renderTexture.Create();
 
             _width = width;
             _height = height;
         }
 
         void _enableUIWidgetsPanel(string font_settings) {
-            UIWidgetsPanel_onEnable(_ptr, _renderTexture.GetNativeTexturePtr(),
+            IntPtr native_tex_ptr =  UIWidgetsPanel_onEnableVK(_ptr,
+            D.assert(native_tex_ptr != IntPtr.Zero);
+            _renderTexture = Texture2D.CreateExternalTexture(_width, _height, TextureFormat.BGRA32, false, true, native_tex_ptr);
-            UIWidgetsPanel_onRenderTexture(_ptr,
-                _renderTexture.GetNativeTexturePtr(),
+            IntPtr native_tex_ptr = UIWidgetsPanel_onRenderTextureVK(_ptr,
+            D.assert(native_tex_ptr != IntPtr.Zero);
+            _renderTexture = Texture2D.CreateExternalTexture(_width, _height, TextureFormat.BGRA32, false, true, native_tex_ptr);
         }
 
         void _disableUIWidgetsPanel() {
             string font_settings);
 
         [DllImport(NativeBindings.dllName)]
+        static extern IntPtr UIWidgetsPanel_onEnableVK(IntPtr ptr, int width, int height, float dpi, string streamingAssetsPath,
+            string font_settings);
+
+        [DllImport(NativeBindings.dllName)]
+        [DllImport(NativeBindings.dllName)]
+        static extern IntPtr UIWidgetsPanel_onRenderTextureVK(
+            IntPtr ptr, int width, int height, float dpi);
     }
 #endif
 

engine/Build.bee.cs

 using Bee.Toolchain.GNU;
 using Bee.Toolchain.IOS;
 using System.Diagnostics;
+using Bee.Toolchain.Android;
 
 enum UIWidgetsBuildTargetPlatform
 {
     {
         return RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
     }
+}
+
+
+class AndroidAppToolchain : AndroidNdkToolchain
+{
+    public AndroidAppToolchain(NPath path) : base(new AndroidNdkLocator(Architecture.Armv7).UseSpecific(path).WithForcedApiLevel(28))
+    {
+    }
+    
 }
 
 //ios build helpers
             "GR_TEST_UTILS=1",
             "SKIA_IMPLEMENTATION=1",
             "SK_GL",
+            "VK_USE_PLATFORM_ANDROID_KHR",
+            "EGL_EGLEXT_PROTOTYPES",
+            "GL_GLEXT_PROTOTYPES",
             "SK_ENABLE_DUMP_GPU",
             "SK_SUPPORT_PDF",
             "SK_CODEC_DECODES_JPEG",
             "-isystem"+ flutterRoot+"/third_party/android_tools/ndk/sources/android/support/include",
             "-isystem"+ flutterRoot +
             "/third_party/android_tools/ndk/sysroot/usr/include/arm-linux-androideabi",
-            //"-D__ANDROID_API__=16",
+            "-D__ANDROID_API__=28",
             // "-fvisibility=hidden",
             "--sysroot="+ flutterRoot+"/third_party/android_tools/ndk/sysroot",
             "-Wstring-conversion",
             "-nostdlib++",
             "-Wl,--warn-shared-textrel",
             "-nostdlib",
-            "--sysroot="+ flutterRoot+"/third_party/android_tools/ndk/platforms/android-16/arch-arm",
+            // "--sysroot="+ flutterRoot+"/third_party/android_tools/ndk/platforms/android-16/arch-arm",
+            "--sysroot="+ flutterRoot+"/third_party/android_tools/ndk/platforms/android-28/arch-arm",
             "-L"+ flutterRoot + "/third_party/android_tools/ndk/sources/cxx-stl/llvm-libc++/libs/armeabi-v7a",
             "-Wl,--build-id=sha1",
             "-g",
         }
         else if (platform == UIWidgetsBuildTargetPlatform.android)
         {
-            var androidToolchain = ToolChain.Store.Android().r19().Armv7();
+            // var androidToolchain = new AndroidAppToolchain(new NPath ("/Applications/Unity/Hub/Editor/2019.4.17f1c1/PlaybackEngines/AndroidPlayer/NDK"));
+            var androidToolchain = new AndroidAppToolchain(new NPath ("/Users/siyao/temp/flutter/engine/src/third_party/android_tools/ndk"));
+
+            //var androidToolchain = ToolChain.Store.Android().r19().Armv7();
 
             var validConfigurations = new List<NativeProgramConfiguration>();
 
+                
+                
+                buildNP.DeployTo("/Users/siyao/temp/androidBuild/Vulkan28/unityLibrary/src/main/jniLibs/armeabi-v7a");
             }
             np.ValidConfigurations = validConfigurations;
         }
                 new SystemLibrary("EGL"),
                 new SystemLibrary("GLESv2"),
                 new SystemLibrary("log"),
+                new SystemLibrary("vulkan"),
             };
         });
     }

engine/src/shell/platform/unity/android/uiwidgets_panel.h

                 float device_pixel_ratio, const char* streaming_assets_path,
                 const char* settings);
 
+  void* OnEnableVK(size_t width, size_t height,
+                float device_pixel_ratio, const char* streaming_assets_path,
+                const char* settings);
+
   void MonoEntrypoint();
 
   void OnDisable();
-
+                
+  void* OnRenderTextureVK(size_t width, size_t height,
+                       float dpi);
+  
   int RegisterTexture(void* native_texture_ptr);
 
   void UnregisterTexture(int texture_id);

engine/src/shell/platform/unity/android/uiwidgets_panel.cc

     process_events_ = true;
   }
 
+  void* UIWidgetsPanel::OnEnableVK( size_t width,
+                                size_t height, float device_pixel_ratio,
+                                const char *streaming_assets_path,
+                                const char *settings)
+  {
+    surface_manager_ = std::make_unique<UnitySurfaceManager>(
+        UIWidgetsSystem::GetInstancePtr()->GetUnityInterfaces());
+
+    FML_DCHECK(fbo_ == 0);
+    surface_manager_->MakeCurrent(EGL_NO_DISPLAY);
+    fbo_ = surface_manager_->CreateRenderSurfaceVK(width, height);
+    surface_manager_->ClearCurrent();
+
+    fml::AutoResetWaitableEvent latch;
+    std::thread::id gfx_worker_thread_id;
+    UIWidgetsSystem::GetInstancePtr()->PostTaskToGfxWorker(
+        [&latch, &gfx_worker_thread_id]() -> void {
+          gfx_worker_thread_id = std::this_thread::get_id();
+          latch.Signal();
+        });
+    latch.Wait();
+
+    gfx_worker_task_runner_ = std::make_unique<GfxWorkerTaskRunner>(
+        gfx_worker_thread_id, [this](const auto *task) {
+          if (UIWidgetsEngineRunTask(engine_, task) != kSuccess)
+          {
+            std::cerr << "Could not post an gfx worker task." << std::endl;
+          }
+        });
+
+    UIWidgetsTaskRunnerDescription render_task_runner = {};
+    render_task_runner.struct_size = sizeof(UIWidgetsTaskRunnerDescription);
+    render_task_runner.identifier = 1;
+    render_task_runner.user_data = gfx_worker_task_runner_.get();
+    render_task_runner.runs_task_on_current_thread_callback =
+        [](void *user_data) -> bool {
+      return static_cast<GfxWorkerTaskRunner *>(user_data)
+          ->RunsTasksOnCurrentThread();
+    };
+    render_task_runner.post_task_callback = [](UIWidgetsTask task,
+                                               uint64_t target_time_nanos,
+                                               void *user_data) -> void {
+      static_cast<GfxWorkerTaskRunner *>(user_data)->PostTask(task,
+                                                              target_time_nanos);
+    };
+
+    UIWidgetsRendererConfig config = {};
+    config.type = kOpenGL;
+    config.open_gl.struct_size = sizeof(config.open_gl);
+    config.open_gl.clear_current = [](void *user_data) -> bool {
+      auto *panel = static_cast<UIWidgetsPanel *>(user_data);
+      return panel->surface_manager_->ClearCurrent();
+    };
+    config.open_gl.make_current = [](void *user_data) -> bool {
+      auto *panel = static_cast<UIWidgetsPanel *>(user_data);
+      return panel->surface_manager_->MakeCurrent(EGL_NO_DISPLAY);
+    };
+    config.open_gl.make_resource_current = [](void *user_data) -> bool {
+      auto *panel = static_cast<UIWidgetsPanel *>(user_data);
+      return panel->surface_manager_->MakeResourceCurrent();
+    };
+    config.open_gl.fbo_callback = [](void *user_data) -> uint32_t {
+      auto *panel = static_cast<UIWidgetsPanel *>(user_data);
+      return panel->fbo_;
+    };
+    config.open_gl.present = [](void *user_data) -> bool { return true; };
+    config.open_gl.gl_proc_resolver = [](void *user_data,
+                                         const char *what) -> void * {
+      return reinterpret_cast<void *>(eglGetProcAddress(what));
+    };
+    config.open_gl.fbo_reset_after_present = true;
+
+    task_runner_ = std::make_unique<CocoaTaskRunner>(
+        gettid(), [this](const auto *task) {
+          if (UIWidgetsEngineRunTask(engine_, task) != kSuccess)
+          {
+            std::cerr << "Could not post an engine task." << std::endl;
+          }
+        });
+
+    UIWidgetsTaskRunnerDescription ui_task_runner = {};
+    ui_task_runner.struct_size = sizeof(UIWidgetsTaskRunnerDescription);
+    ui_task_runner.identifier = 2;
+    ui_task_runner.user_data = task_runner_.get();
+
+    ui_task_runner.runs_task_on_current_thread_callback =
+        [](void *user_data) -> bool {
+      return static_cast<CocoaTaskRunner *>(user_data)->RunsTasksOnCurrentThread();
+    };
+    ui_task_runner.post_task_callback = [](UIWidgetsTask task,
+                                           uint64_t target_time_nanos,
+                                           void *user_data) -> void {
+      static_cast<CocoaTaskRunner *>(user_data)->PostTask(task, target_time_nanos);
+    };
+
+    UIWidgetsCustomTaskRunners custom_task_runners = {};
+    custom_task_runners.struct_size = sizeof(UIWidgetsCustomTaskRunners);
+    custom_task_runners.platform_task_runner = &ui_task_runner;
+    custom_task_runners.ui_task_runner = &ui_task_runner;
+    custom_task_runners.render_task_runner = &render_task_runner;
+
+    UIWidgetsProjectArgs args = {};
+    args.struct_size = sizeof(UIWidgetsProjectArgs);
+
+    args.assets_path = streaming_assets_path;
+    args.font_asset = settings;
+
+    args.icu_mapper = GetICUStaticMapping;
+
+    // // Used for IOS build
+    // // std::string icu_symbol_prefix = "_binary_icudtl_dat_start";
+    // // std::string native_lib_path =
+    // // "pathtodll/Plugins/x86_64/libUIWidgets_d.dll"; args.icu_mapper =
+    // // [icu_symbol_prefix, native_lib_path] {
+    // //  return GetSymbolMapping(icu_symbol_prefix, native_lib_path);
+    // // };
+    args.command_line_argc = 0;
+    args.command_line_argv = nullptr;
+
+    args.platform_message_callback =
+        [](const UIWidgetsPlatformMessage *engine_message,
+           void *user_data) -> void {};
+
+    args.custom_task_runners = &custom_task_runners;
+    args.task_observer_add = [](intptr_t key, void *callback,
+                                void *user_data) -> void {
+      auto *panel = static_cast<UIWidgetsPanel *>(user_data);
+      panel->task_runner_->AddTaskObserver(key,
+                                           *static_cast<fml::closure *>(callback));
+    };
+    args.task_observer_remove = [](intptr_t key, void *user_data) -> void {
+      auto *panel = static_cast<UIWidgetsPanel *>(user_data);
+      panel->task_runner_->RemoveTaskObserver(key);
+    };
+
+    args.custom_mono_entrypoint = [](void *user_data) -> void {
+      auto *panel = static_cast<UIWidgetsPanel *>(user_data);
+      panel->MonoEntrypoint();
+    };
+
+    args.vsync_callback = [](void *user_data, intptr_t baton) -> void {
+      auto *panel = static_cast<UIWidgetsPanel *>(user_data);
+      panel->VSyncCallback(baton);
+    };
+
+    args.initial_window_metrics.width = width;
+    args.initial_window_metrics.height = height;
+    args.initial_window_metrics.pixel_ratio = device_pixel_ratio;
+
+    UIWidgetsEngine engine = nullptr;
+    auto result = UIWidgetsEngineInitialize(&config, &args, this, &engine);
+
+    if (result != kSuccess || engine == nullptr)
+    {
+      std::cerr << "Failed to start UIWidgets engine: error " << result
+                << std::endl;
+      return nullptr;
+    }
+
+    engine_ = engine;
+    UIWidgetsEngineRunInitialized(engine);
+
+    UIWidgetsSystem::GetInstancePtr()->RegisterPanel(this);
+
+    process_events_ = true;
+    return static_cast<void*>(surface_manager_->GetInnerTexture());
+  }
+
   void UIWidgetsPanel::MonoEntrypoint() { entrypoint_callback_(handle_); }
 
   void UIWidgetsPanel::OnDisable()
     metrics.physical_height = static_cast<float>(height);
     metrics.device_pixel_ratio = device_pixel_ratio;
     reinterpret_cast<EmbedderEngine *>(engine_)->SetViewportMetrics(metrics);
+  }
+
+  void* UIWidgetsPanel::OnRenderTextureVK(size_t width,
+                                       size_t height, float device_pixel_ratio)
+  {
+    ViewportMetrics metrics;
+    metrics.physical_width = static_cast<float>(width);
+    metrics.physical_height = static_cast<float>(height);
+    metrics.device_pixel_ratio = device_pixel_ratio;
+    reinterpret_cast<EmbedderEngine *>(engine_)->SetViewportMetrics(metrics);
+
+    fbo_ = surface_manager_->CreateRenderSurfaceVK(width, height);
+    return static_cast<void*>(surface_manager_->GetInnerTexture());
   }
 
   int UIWidgetsPanel::RegisterTexture(void *native_texture_ptr)
                     streaming_assets_path, settings);
   }
 
+  UIWIDGETS_API(void*)
+  UIWidgetsPanel_onEnableVK(UIWidgetsPanel *panel,
+                          size_t width, size_t height, float device_pixel_ratio,
+                          const char *streaming_assets_path,
+                          const char *settings)
+  {
+    return panel->OnEnableVK(width, height, device_pixel_ratio,
+                    streaming_assets_path, settings);
+  }
+
   UIWIDGETS_API(void)
   UIWidgetsPanel_onDisable(UIWidgetsPanel *panel)
   {
                                  int width, int height, float dpi)
   {
     panel->OnRenderTexture(native_texture_ptr, width, height, dpi);
+  }
+
+  UIWIDGETS_API(void*)
+  UIWidgetsPanel_onRenderTextureVK(UIWidgetsPanel *panel,
+                                 int width, int height, float dpi)
+  {
+    return panel->OnRenderTextureVK( width, height, dpi);
   }
 
   UIWIDGETS_API(int)

engine/src/shell/platform/unity/android/unity_surface_manager.cc

 
 #include <flutter/fml/logging.h>
 #include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2ext.h>
+
+#include <vulkan/vulkan.h>
+#include <vulkan/vulkan_core.h>
+#include <android/hardware_buffer.h>
+
+#define UNITY_USED_VULKAN_API_FUNCTIONS(apply)        \
+  apply(vkGetDeviceProcAddr);                         \
+  apply(vkCreateInstance);                            \
+  apply(vkCmdBeginRenderPass);                        \
+  apply(vkCreateBuffer);                              \
+  apply(vkGetPhysicalDeviceMemoryProperties);         \
+  apply(vkGetBufferMemoryRequirements);               \
+  apply(vkMapMemory);                                 \
+  apply(vkBindBufferMemory);                          \
+  apply(vkAllocateMemory);                            \
+  apply(vkDestroyBuffer);                             \
+  apply(vkFreeMemory);                                \
+  apply(vkUnmapMemory);                               \
+  apply(vkQueueWaitIdle);                             \
+  apply(vkDeviceWaitIdle);                            \
+  apply(vkCmdCopyBufferToImage);                      \
+  apply(vkFlushMappedMemoryRanges);                   \
+  apply(vkCreatePipelineLayout);                      \
+  apply(vkCreateShaderModule);                        \
+  apply(vkDestroyShaderModule);                       \
+  apply(vkCreateGraphicsPipelines);                   \
+  apply(vkCmdBindPipeline);                           \
+  apply(vkCmdDraw);                                   \
+  apply(vkCmdPushConstants);                          \
+  apply(vkCmdBindVertexBuffers);                      \
+  apply(vkDestroyPipeline);                           \
+  apply(vkGetAndroidHardwareBufferPropertiesANDROID); \
+  apply(vkDestroyPipelineLayout);
+
+#define VULKAN_DEFINE_API_FUNCPTR(func) static PFN_##func my_##func
+VULKAN_DEFINE_API_FUNCPTR(vkGetInstanceProcAddr);
+UNITY_USED_VULKAN_API_FUNCTIONS(VULKAN_DEFINE_API_FUNCPTR);
+#undef VULKAN_DEFINE_API_FUNCPTR
+
+static void LoadVulkanAPI(PFN_vkGetInstanceProcAddr getInstanceProcAddr,
+                          VkInstance instance)
+{
+  if (!my_vkGetInstanceProcAddr && getInstanceProcAddr)
+    my_vkGetInstanceProcAddr = getInstanceProcAddr;
+
+  if (!my_vkCreateInstance)
+    my_vkCreateInstance = (PFN_vkCreateInstance)my_vkGetInstanceProcAddr(
+        VK_NULL_HANDLE, "vkCreateInstance");
+
+#define LOAD_VULKAN_FUNC(fn) \
+  if (!my_##fn)              \
+  my_##fn = (PFN_##fn)my_vkGetInstanceProcAddr(instance, #fn)
+  UNITY_USED_VULKAN_API_FUNCTIONS(LOAD_VULKAN_FUNC);
+#undef LOAD_VULKAN_FUNC
+}
+
 namespace uiwidgets
 {
 
     return fbo_;
   }
 
+  bool getMemoryTypeIndex(uint32_t typeBits, VkPhysicalDevice device, VkFlags quirementsMaks,
+                          uint32_t &index)
+  {
+    // const auto& memoryPropertys =
+    //     VulkanManager::Get().physical->mempryProperties;
+    VkPhysicalDeviceMemoryProperties memoryPropertys;
+    vkGetPhysicalDeviceMemoryProperties(device, &memoryPropertys);
+    for (uint32_t i = 0; i < memoryPropertys.memoryTypeCount; i++)
+    {
+      if ((typeBits & 1) == 1)
+      {
+        // Type is available, does it match user properties?
+        if ((memoryPropertys.memoryTypes[i].propertyFlags &
+             quirementsMaks) == quirementsMaks)
+        {
+          index = i;
+          return true;
+        }
+      }
+      typeBits >>= 1;
+    }
+    return false;
+  }
+
+  GLuint UnitySurfaceManager::CreateRenderSurfaceVK(int width, int height)
+  {
+    if (m_UnityVulkan != nullptr)
+    {
+      auto vkDevice = m_Instance.device;
+      // auto memoryPropertys = m_Instance.memoryTypeIndex;
+      // VkImage vkImage;
+      bool useExternalFormat = true;
+
+      AHardwareBuffer *buffer = nullptr;
+
+      AHardwareBuffer_Desc usage = {};
+      // filling in the usage for HardwareBuffer
+      usage.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+      usage.height = width; //format.height;
+      usage.width = height;  //format.width;
+      usage.layers = 1;
+      usage.rfu0 = 0;
+      usage.rfu1 = 0;
+      usage.stride = 0;
+      usage.usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
+                  AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER |
+                  AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
+      FML_CHECK(AHardwareBuffer_allocate(&usage, &buffer) == 0);
+      VkResult err;
+
+      AHardwareBuffer_Desc bufferDesc;
+      AHardwareBuffer_describe(buffer, &bufferDesc);
+
+      VkAndroidHardwareBufferFormatPropertiesANDROID formatInfo = {
+          .sType =
+              VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
+          .pNext = nullptr,
+      };
+      VkAndroidHardwareBufferPropertiesANDROID properties = {
+          .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
+          .pNext = &formatInfo,
+      };
+      err = vkGetAndroidHardwareBufferPropertiesANDROID(vkDevice, buffer, &properties);
+
+      VkExternalFormatANDROID externalFormat{
+          .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
+          .pNext = nullptr,
+          .externalFormat = formatInfo.externalFormat,
+      };
+      VkExternalMemoryImageCreateInfo externalCreateInfo{
+          .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+          .pNext = &externalFormat,
+          .handleTypes =
+              VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+      };
+
+
+      VkImageCreateInfo imageInfo = {};
+      imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+      imageInfo.pNext = &externalCreateInfo;
+      imageInfo.flags = 0;
+      imageInfo.imageType = VK_IMAGE_TYPE_2D;
+      imageInfo.format =
+          VK_FORMAT_UNDEFINED;
+      imageInfo.extent = {
+          bufferDesc.width,
+          bufferDesc.height,
+          1,
+      };
+      imageInfo.mipLevels = 1, imageInfo.arrayLayers = 1;
+      imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+      imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+      imageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+      imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+      imageInfo.queueFamilyIndexCount = 0;
+      imageInfo.pQueueFamilyIndices = nullptr;
+      imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+      auto result = vkCreateImage(vkDevice, &imageInfo, nullptr, &vk_Image_);
+
+      VkImportAndroidHardwareBufferInfoANDROID androidHardwareBufferInfo{
+          .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+          .pNext = nullptr,
+          .buffer = buffer,
+      };
+      VkMemoryDedicatedAllocateInfo memoryAllocateInfo{
+          .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+          .pNext = &androidHardwareBufferInfo,
+          .image = vk_Image_,
+          .buffer = VK_NULL_HANDLE,
+      };
+      // android的hardbuffer位置(properties)
+      VkMemoryRequirements requires;
+      vkGetImageMemoryRequirements(vkDevice, vk_Image_, &requires);
+
+      VkPhysicalDeviceMemoryProperties2 phyDevMemProps;
+      phyDevMemProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
+      phyDevMemProps.pNext = nullptr;
+
+      uint32_t memoryTypeIndex = 0;
+      bool getIndex =
+        getMemoryTypeIndex(properties.memoryTypeBits, m_Instance.physicalDevice, 0, memoryTypeIndex);
+
+      VkMemoryAllocateInfo memoryInfo = {};
+      memoryInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+      memoryInfo.pNext = &memoryAllocateInfo;
+      memoryInfo.memoryTypeIndex = memoryTypeIndex;
+      memoryInfo.allocationSize = properties.allocationSize;
+
+      vkAllocateMemory(vkDevice, &memoryInfo, nullptr, &memory);
+
+      VkBindImageMemoryInfo bindImageInfo;
+      bindImageInfo.sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
+      bindImageInfo.pNext = nullptr;
+      bindImageInfo.image = vk_Image_;
+      bindImageInfo.memory = memory;
+      bindImageInfo.memoryOffset = 0;
+      // vkBindImageMemory2KHR(vkDevice, 1, &bindImageInfo);
+      vkBindImageMemory2(vkDevice, 1, &bindImageInfo);
+
+      eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_context_);
+
+      // android绑定AHardwareBuffer与egl image
+      EGLClientBuffer native_buffer = eglGetNativeClientBufferANDROID(buffer);
+      assert(native_buffer);
+      auto success = false;
+      EGLint attrs[] = {EGL_NONE};
+
+      EGLImageKHR image = eglCreateImageKHR(egl_display_, EGL_NO_CONTEXT,
+                                            EGL_NATIVE_BUFFER_ANDROID, native_buffer, attrs);
+      FML_DCHECK(image != EGL_NO_IMAGE_KHR);
+
+      GLuint mTexture = 0;
+      glGenTextures(1, &mTexture);
+      glGenFramebuffers(1, &fbo_);
+      glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
+
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTexture, 0);
+
+      
+      glActiveTexture(GL_TEXTURE0);
+      glBindTexture(GL_TEXTURE_2D, mTexture);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+      glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTexture, 0);
+      FML_DCHECK(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+        auto x = glGetError();
+        glEnable(GL_TEXTURE_2D);
+        x = glGetError();
+
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
+        x = glGetError();
+        glViewport(0,0,200, 200);
+        x = glGetError();
+
+        glClearColor(0,0,1,0);
+        x = glGetError();
+        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+        x = glGetError();
+
+      // return fbo_;
+      return 0;
+    }
+    return 0;
+  }
+
   void UnitySurfaceManager::DestroyRenderSurface()
   {
     FML_DCHECK(fbo_ != 0);
 
   void UnitySurfaceManager::GetUnityContext()
   {
-    if(egl_unity_context_ != nullptr){
+    if (egl_unity_context_ != nullptr)
+    {
-    FML_CHECK(egl_display_ != EGL_NO_DISPLAY)
-        << "Renderer type is invalid";
+  static const int DEV_W = 16, DEV_H = 16;
+
+  
+
-    FML_CHECK(egl_display_ != EGL_NO_DISPLAY)
-        << "Renderer type is invalid";
+    auto *graphics = unity_interfaces->Get<IUnityGraphics>();
+    UnityGfxRenderer renderer = graphics->GetRenderer();
+    FML_DCHECK(renderer == kUnityGfxRendererOpenGLES30 ||
+               renderer == kUnityGfxRendererOpenGLES20 ||
+               renderer == kUnityGfxRendererVulkan);
-    // Initialize the display connection.
-    FML_CHECK(eglInitialize(egl_display_, nullptr, nullptr) == EGL_TRUE)
-        << "Renderer type is invalid";
+    if (renderer == kUnityGfxRendererVulkan)
+    {
+      m_UnityVulkan = unity_interfaces->Get<IUnityGraphicsVulkan>();
+      m_Instance = m_UnityVulkan->Instance();
+      LoadVulkanAPI(m_Instance.getInstanceProcAddr, m_Instance.instance);
+      // auto VkPhysicalDevice = m_Instance.physicalDevice;
-    auto valid_ = true;
+      auto success = false;
-    bool success = false;
+      egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY); // eglGetCurrentDisplay(); //
+      
+      FML_CHECK(egl_display_ != EGL_NO_DISPLAY);
+      FML_CHECK(eglInitialize(egl_display_, nullptr, nullptr) == EGL_TRUE);
+      
+      eglBindAPI(EGL_OPENGL_ES_API);
-    std::tie(success, egl_config_) = ChooseEGLConfiguration(egl_display_);
-    FML_CHECK(success) << "Could not choose an EGL configuration.";
+      std::tie(success, egl_config_) = ChooseEGLConfiguration(egl_display_);
+      FML_CHECK(success) << "Could not choose an EGL configuration.";
+
+      std::tie(success, egl_context_) = CreateContext(egl_display_, egl_config_, EGL_NO_CONTEXT);
+      std::tie(success, egl_resource_context_) = CreateContext(egl_display_, egl_config_, egl_context_);
+      
+      return success;
+    }
+    else
+    {
+      // Make sure Vulkan API functions are loaded
+
+      FML_CHECK(egl_display_ != EGL_NO_DISPLAY)
+          << "Renderer type is invalid";
+
+      // Initialize the display connection.
+      FML_CHECK(eglInitialize(egl_display_, nullptr, nullptr) == EGL_TRUE)
+          << "Renderer type is invalid";
+
+      auto valid_ = true;
+
+      bool success = false;
-    std::tie(success, egl_context_) = CreateContext(egl_display_, egl_config_, egl_unity_context_);
+      std::tie(success, egl_config_) = ChooseEGLConfiguration(egl_display_);
+      FML_CHECK(success) << "Could not choose an EGL configuration.";
-    std::tie(success, egl_resource_context_) = CreateContext(egl_display_, egl_config_, egl_context_);
+      std::tie(success, egl_context_) = CreateContext(egl_display_, egl_config_, egl_unity_context_);
-    return success;
+      std::tie(success, egl_resource_context_) = CreateContext(egl_display_, egl_config_, egl_context_);
+      return success;
+    }
   }
 
   void UnitySurfaceManager::CleanUp()

engine/src/shell/platform/unity/android/unity_surface_manager.h

 
 #include "Unity/IUnityGraphics.h"
 
+#include "Unity/IUnityGraphicsVulkan.h"
+#include "include/gpu/vk/GrVkBackendContext.h"
+
 namespace uiwidgets
 {
 
     ~UnitySurfaceManager();
 
     GLuint CreateRenderSurface(void *native_texture_ptr);
+    GLuint CreateRenderSurfaceVK(int width, int height);
+
+    void* GetInnerTexture() { 
+      // return (void*)vk_Image_; 
+      return (void*)&vk_Image_; 
+    }
+
     bool ClearCurrent();
 
     bool MakeCurrent(const EGLSurface surface);
     EGLContext egl_context_;
     EGLContext egl_resource_context_;
     EGLConfig egl_config_;
+    
+    IUnityGraphicsVulkan* m_UnityVulkan;
+    UnityVulkanInstance m_Instance;
+    sk_sp<GrContext> gr_context_;
+    sk_sp<SkSurface> m_SkSurface;
+    VkImage vk_Image_;
+    VkDeviceMemory memory;
 
     bool initialize_succeeded_;