@shopify/react-native-skia 1.5.3 → 1.5.5

package/android/cpp/rnskia-android/opengl/Display.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <memory>
+
+#include "EGL/egl.h"
+#include "GLES2/gl2.h"
+
+#include "opengl/Context.h"
+#include "opengl/Error.h"
+
+namespace RNSkia {
+
+class Context;
+class Surface;
+
+class Display {
+public:
+  Display() {
+    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+
+    if (eglInitialize(display, nullptr, nullptr) != EGL_TRUE) {
+      LOG_EGL_ERROR;
+      return;
+    }
+    _display = display;
+  }
+
+  ~Display() {
+    if (_display != EGL_NO_DISPLAY) {
+      if (eglTerminate(_display) != EGL_TRUE) {
+        LOG_EGL_ERROR;
+      }
+    }
+  }
+
+  bool isValid() const { return _display != EGL_NO_DISPLAY; }
+
+  EGLConfig chooseConfig() const {
+
+    EGLint att[] = {EGL_RENDERABLE_TYPE,
+                    EGL_OPENGL_ES2_BIT,
+                    EGL_ALPHA_SIZE,
+                    8,
+                    EGL_BLUE_SIZE,
+                    8,
+                    EGL_GREEN_SIZE,
+                    8,
+                    EGL_RED_SIZE,
+                    8,
+                    EGL_DEPTH_SIZE,
+                    0,
+                    EGL_STENCIL_SIZE,
+                    0,
+                    EGL_SAMPLE_BUFFERS,
+                    0,
+                    EGL_NONE};
+
+    EGLint numConfigs;
+    EGLConfig glConfig = 0;
+    if (eglChooseConfig(_display, att, &glConfig, 1, &numConfigs) != EGL_TRUE ||
+        numConfigs == 0) {
+      LOG_EGL_ERROR;
+      return 0;
+    }
+
+    return glConfig;
+  }
+
+  std::unique_ptr<Context> makeContext(const EGLConfig &config,
+                                       const Context *share_context) {
+    EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
+    auto context = eglCreateContext(
+        _display, config,
+        share_context != nullptr ? share_context->getHandle() : nullptr,
+        contextAttribs);
+
+    if (context == EGL_NO_CONTEXT) {
+      LOG_EGL_ERROR;
+      return nullptr;
+    }
+    return std::unique_ptr<Context>(new Context(_display, context));
+  }
+
+  std::unique_ptr<Surface> makeWindowSurface(const EGLConfig &config,
+                                             EGLNativeWindowType window) {
+    const EGLint attribs[] = {EGL_NONE};
+    auto surface = eglCreateWindowSurface(_display, config, window, attribs);
+    if (surface == EGL_NO_SURFACE) {
+      LOG_EGL_ERROR;
+      return nullptr;
+    }
+    return std::unique_ptr<Surface>(new Surface(_display, surface));
+  }
+
+  std::unique_ptr<Surface> makePixelBufferSurface(const EGLConfig &config,
+                                                  size_t width, size_t height) {
+    const EGLint attribs[] = {EGL_WIDTH, static_cast<EGLint>(width), EGL_HEIGHT,
+                              static_cast<EGLint>(height), EGL_NONE};
+    auto surface = eglCreatePbufferSurface(_display, config, attribs);
+    if (surface == EGL_NO_SURFACE) {
+      LOG_EGL_ERROR;
+      return nullptr;
+    }
+    return std::unique_ptr<Surface>(new Surface(_display, surface));
+  }
+
+  const EGLDisplay &getHandle() const { return _display; }
+
+private:
+  EGLDisplay _display = EGL_NO_DISPLAY;
+
+  Display(const Display &) = delete;
+
+  Display &operator=(const Display &) = delete;
+};
+
+} // namespace RNSkia

package/android/cpp/rnskia-android/opengl/Error.cpp

@@ -0,0 +1,9 @@
+#include "opengl/Error.h"
+
+#include "RNSkLog.h"
+
+void LogEGLError(const char *file, int line) {
+  const auto error = eglGetError();
+  RNSkia::RNSkLogger::logToConsole("EGL Error: %s (%d) in %s:%d",
+                                   EGLErrorToString(error), error, file, line);
+}

package/android/cpp/rnskia-android/opengl/Error.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "EGL/egl.h"
+#include "GLES2/gl2.h"
+
+#define LOG_EGL_ERROR LogEGLError(__FILE__, __LINE__);
+
+static const char *EGLErrorToString(EGLint error) {
+  switch (error) {
+  case EGL_SUCCESS:
+    return "Success";
+  case EGL_NOT_INITIALIZED:
+    return "Not Initialized";
+  case EGL_BAD_ACCESS:
+    return "Bad Access";
+  case EGL_BAD_ALLOC:
+    return "Bad Alloc";
+  case EGL_BAD_ATTRIBUTE:
+    return "Bad Attribute";
+  case EGL_BAD_CONTEXT:
+    return "Bad Context";
+  case EGL_BAD_CONFIG:
+    return "Bad Config";
+  case EGL_BAD_CURRENT_SURFACE:
+    return "Bad Current Surface";
+  case EGL_BAD_DISPLAY:
+    return "Bad Display";
+  case EGL_BAD_SURFACE:
+    return "Bad Surface";
+  case EGL_BAD_MATCH:
+    return "Bad Match";
+  case EGL_BAD_PARAMETER:
+    return "Bad Parameter";
+  case EGL_BAD_NATIVE_PIXMAP:
+    return "Bad Native Pixmap";
+  case EGL_BAD_NATIVE_WINDOW:
+    return "Bad Native Window";
+  case EGL_CONTEXT_LOST:
+    return "Context Lost";
+  }
+  return "Unknown";
+}
+
+void LogEGLError(const char *file, int line);

package/android/cpp/rnskia-android/opengl/Surface.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "opengl/Error.h"
+
+namespace RNSkia {
+
+class Surface {
+public:
+  ~Surface() {
+    if (_surface != EGL_NO_SURFACE) {
+      if (eglDestroySurface(_display, _surface) != EGL_TRUE) {
+        LOG_EGL_ERROR;
+      }
+    }
+  }
+
+  bool isValid() { return _surface != EGL_NO_SURFACE; }
+
+  const EGLSurface &getHandle() const { return _surface; }
+
+  bool Present() const {
+    const auto result = eglSwapBuffers(_display, _surface) == EGL_TRUE;
+    if (!result) {
+      LOG_EGL_ERROR;
+    }
+    return result;
+  }
+
+private:
+  friend class Display;
+
+  EGLDisplay _display = EGL_NO_DISPLAY;
+  EGLSurface _surface = EGL_NO_SURFACE;
+
+  Surface(EGLDisplay display, EGLSurface surface)
+      : _display(display), _surface(surface) {}
+
+  Surface(const Surface &) = delete;
+
+  Surface &operator=(const Surface &) = delete;
+};
+
+} // Namespace RNSkia

package/android/src/main/java/com/shopify/reactnative/skia/SkiaBaseView.java

@@ -3,7 +3,6 @@ package com.shopify.reactnative.skia;
 import android.content.Context;
 import android.graphics.SurfaceTexture;
 import android.util.Log;
-import android.view.MotionEvent;
 import android.view.TextureView;
 
 import com.facebook.react.views.view.ReactViewGroup;

package/cpp/api/JsiSkImage.h

@@ -12,6 +12,11 @@
 
 #include "RNSkTypedArray.h"
 
+#if defined(SK_GRAPHITE)
+#include "DawnContext.h"
+#include "include/gpu/graphite/Context.h"
+#endif
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
@@ -83,9 +88,13 @@ public:
                        ? arguments[1].asNumber()
                        : 100.0;
     auto image = getObject();
+#if defined(SK_GRAPHITE)
+    image = DawnContext::getInstance().MakeRasterImage(image);
+#else
     if (image->isTextureBacked()) {
       image = image->makeNonTextureImage();
     }
+#endif
     sk_sp<SkData> data;
 
     if (format == SkEncodedImageFormat::kJPEG) {
@@ -181,9 +190,13 @@ public:
   }
 
   JSI_HOST_FUNCTION(makeNonTextureImage) {
-    auto image = getObject()->makeNonTextureImage();
+#if defined(SK_GRAPHITE)
+    auto rasterImage = DawnContext::getInstance().MakeRasterImage(getObject());
+#else
+    auto rasterImage = getObject()->makeNonTextureImage();
+#endif
     return jsi::Object::createFromHostObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+        runtime, std::make_shared<JsiSkImage>(getContext(), rasterImage));
   }
 
   EXPORT_JSI_API_TYPENAME(JsiSkImage, Image)

package/cpp/api/JsiSkSurface.h

@@ -10,6 +10,10 @@
 #include "JsiSkCanvas.h"
 #include "JsiSkImage.h"
 
+#if defined(SK_GRAPHITE)
+#include "DawnContext.h"
+#endif
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
@@ -44,21 +48,32 @@ public:
   }
 
   JSI_HOST_FUNCTION(flush) {
-    if (auto dContext = GrAsDirectContext(getObject()->recordingContext())) {
+    auto surface = getObject();
+#if defined(SK_GRAPHITE)
+    auto recording = surface->recorder()->snap();
+    DawnContext::getInstance().submitRecording(recording.get());
+#else
+    if (auto dContext = GrAsDirectContext(surface->recordingContext())) {
       dContext->flushAndSubmit();
     }
+#endif
     return jsi::Value::undefined();
   }
 
   JSI_HOST_FUNCTION(makeImageSnapshot) {
+    auto surface = getObject();
     sk_sp<SkImage> image;
     if (count == 1) {
       auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
-      image = getObject()->makeImageSnapshot(SkIRect::MakeXYWH(
+      image = surface->makeImageSnapshot(SkIRect::MakeXYWH(
           rect->x(), rect->y(), rect->width(), rect->height()));
     } else {
-      image = getObject()->makeImageSnapshot();
+      image = surface->makeImageSnapshot();
     }
+#if defined(SK_GRAPHITE)
+    auto recording = surface->recorder()->snap();
+    DawnContext::getInstance().submitRecording(recording.get());
+#endif
     return jsi::Object::createFromHostObject(
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }

package/cpp/rnskia/DawnContext.h

@@ -0,0 +1,241 @@
+#pragma once
+
+#include <memory>
+#include <mutex>
+
+#include "DawnUtils.h"
+#include "DawnWindowContext.h"
+#include "ImageProvider.h"
+
+#include "include/core/SkData.h"
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/Context.h"
+#include "include/gpu/graphite/ContextOptions.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/Recorder.h"
+#include "include/gpu/graphite/Recording.h"
+#include "include/gpu/graphite/Surface.h"
+#include "include/gpu/graphite/dawn/DawnBackendContext.h"
+#include "include/gpu/graphite/dawn/DawnTypes.h"
+#include "include/gpu/graphite/dawn/DawnUtils.h"
+
+#include "src/gpu/graphite/ContextOptionsPriv.h"
+
+#ifdef __APPLE__
+#include <CoreVideo/CVPixelBuffer.h>
+#else
+#include <android/hardware_buffer.h>
+#include <android/hardware_buffer_jni.h>
+#endif
+
+namespace RNSkia {
+
+struct AsyncContext {
+  bool fCalled = false;
+  std::unique_ptr<const SkSurface::AsyncReadResult> fResult;
+};
+
+struct SharedTextureContext {
+  wgpu::SharedTextureMemory sharedTextureMemory;
+  wgpu::Texture texture;
+};
+
+static void
+async_callback(void *c,
+               std::unique_ptr<const SkImage::AsyncReadResult> result) {
+  auto context = static_cast<AsyncContext *>(c);
+  context->fResult = std::move(result);
+  context->fCalled = true;
+}
+
+class DawnContext {
+public:
+  // TODO: remove
+  friend class RNSkiOSPlatformContext;
+
+  DawnContext(const DawnContext &) = delete;
+  DawnContext &operator=(const DawnContext &) = delete;
+
+  static DawnContext &getInstance() {
+    static DawnContext instance;
+    return instance;
+  }
+
+  sk_sp<SkImage> MakeRasterImage(sk_sp<SkImage> image) {
+    if (!image->isTextureBacked()) {
+      return image;
+    }
+    std::lock_guard<std::mutex> lock(_mutex);
+    AsyncContext asyncContext;
+    fGraphiteContext->asyncRescaleAndReadPixels(
+        image.get(), image->imageInfo(), image->imageInfo().bounds(),
+        SkImage::RescaleGamma::kSrc, SkImage::RescaleMode::kNearest,
+        async_callback, &asyncContext);
+    fGraphiteContext->submit();
+    while (!asyncContext.fCalled) {
+      tick();
+      fGraphiteContext->checkAsyncWorkCompletion();
+    }
+    auto bytesPerRow = asyncContext.fResult->rowBytes(0);
+    auto bufferSize = bytesPerRow * image->imageInfo().height();
+    auto data = SkData::MakeWithProc(
+        asyncContext.fResult->data(0), bufferSize,
+        [](const void *ptr, void *context) {
+          auto *result =
+              reinterpret_cast<const SkSurface::AsyncReadResult *>(context);
+          delete result;
+        },
+        reinterpret_cast<void *>(const_cast<SkSurface::AsyncReadResult *>(
+            asyncContext.fResult.release())));
+    auto rasterImage =
+        SkImages::RasterFromData(image->imageInfo(), data, bytesPerRow);
+    return rasterImage;
+  }
+
+  void submitRecording(
+      skgpu::graphite::Recording *recording,
+      skgpu::graphite::SyncToCpu syncToCpu = skgpu::graphite::SyncToCpu::kNo) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    skgpu::graphite::InsertRecordingInfo info;
+    info.fRecording = recording;
+    fGraphiteContext->insertRecording(info);
+    fGraphiteContext->submit(syncToCpu);
+  }
+
+  sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+#ifdef __APPLE__
+    wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc;
+    auto ioSurface = CVPixelBufferGetIOSurface((CVPixelBufferRef)buffer);
+    platformDesc.ioSurface = ioSurface;
+    int width = static_cast<int>(IOSurfaceGetWidth(ioSurface));
+    int height = static_cast<int>(IOSurfaceGetHeight(ioSurface));
+#else
+    wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc;
+    auto ahb = (AHardwareBuffer *)buffer;
+    platformDesc.handle = ahb;
+    platformDesc.useExternalFormat = true;
+    AHardwareBuffer_Desc adesc;
+    AHardwareBuffer_describe(ahb, &adesc);
+    int width = adesc.width;
+    int height = adesc.height;
+#endif
+
+    wgpu::SharedTextureMemoryDescriptor desc = {};
+    desc.nextInChain = &platformDesc;
+    wgpu::SharedTextureMemory memory =
+        backendContext.fDevice.ImportSharedTextureMemory(&desc);
+
+    wgpu::TextureDescriptor textureDesc;
+    textureDesc.format = DawnUtils::PreferredTextureFormat;
+    textureDesc.dimension = wgpu::TextureDimension::e2D;
+    textureDesc.usage =
+        wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopySrc;
+    textureDesc.size = {static_cast<uint32_t>(width),
+                        static_cast<uint32_t>(height), 1};
+
+    wgpu::Texture texture = memory.CreateTexture(&textureDesc);
+
+    wgpu::SharedTextureMemoryBeginAccessDescriptor beginAccessDesc;
+    beginAccessDesc.initialized = true;
+    beginAccessDesc.fenceCount = 0;
+    bool success = memory.BeginAccess(texture, &beginAccessDesc);
+
+    if (success) {
+      skgpu::graphite::BackendTexture betFromView =
+          skgpu::graphite::BackendTextures::MakeDawn(texture.Get());
+      auto result = SkImages::WrapTexture(
+          getRecorder(), betFromView, DawnUtils::PreferedColorType,
+          kPremul_SkAlphaType, nullptr,
+          [](void *context) {
+            auto ctx = static_cast<SharedTextureContext *>(context);
+            wgpu::SharedTextureMemoryEndAccessState endState = {};
+            ctx->sharedTextureMemory.EndAccess(ctx->texture, &endState);
+            delete ctx;
+          },
+          new SharedTextureContext{memory, texture});
+      return result;
+    }
+    if (!success) {
+      return nullptr;
+    }
+    return nullptr;
+  }
+
+  // Create offscreen surface
+  sk_sp<SkSurface> MakeOffscreen(int width, int height) {
+    SkImageInfo info = SkImageInfo::Make(
+        width, height, DawnUtils::PreferedColorType, kPremul_SkAlphaType);
+    sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(getRecorder(), info);
+
+    if (!surface) {
+      throw std::runtime_error("Failed to create offscreen Skia surface.");
+    }
+
+    return surface;
+  }
+
+  // Create onscreen surface with window
+  std::unique_ptr<WindowContext> MakeWindow(void *window, int width,
+                                            int height) {
+    // 1. Create Surface
+    wgpu::SurfaceDescriptor surfaceDescriptor;
+#ifdef __APPLE__
+    wgpu::SurfaceDescriptorFromMetalLayer metalSurfaceDesc;
+    metalSurfaceDesc.layer = window;
+    surfaceDescriptor.nextInChain = &metalSurfaceDesc;
+#else
+    wgpu::SurfaceDescriptorFromAndroidNativeWindow androidSurfaceDesc;
+    androidSurfaceDesc.window = window;
+    surfaceDescriptor.nextInChain = &androidSurfaceDesc;
+#endif
+    auto surface =
+        wgpu::Instance(instance->Get()).CreateSurface(&surfaceDescriptor);
+    return std::make_unique<DawnWindowContext>(
+        getRecorder(), backendContext.fDevice, surface, width, height);
+  }
+
+private:
+  std::unique_ptr<dawn::native::Instance> instance;
+  std::unique_ptr<skgpu::graphite::Context> fGraphiteContext;
+  skgpu::graphite::DawnBackendContext backendContext;
+  std::mutex _mutex;
+
+  DawnContext() {
+    DawnProcTable backendProcs = dawn::native::GetProcs();
+    dawnProcSetProcs(&backendProcs);
+    WGPUInstanceDescriptor desc{};
+    desc.features.timedWaitAnyEnable = true;
+    instance = std::make_unique<dawn::native::Instance>(&desc);
+
+    backendContext = DawnUtils::createDawnBackendContext(instance.get());
+
+    skgpu::graphite::ContextOptions ctxOptions;
+    skgpu::graphite::ContextOptionsPriv contextOptionsPriv;
+    ctxOptions.fOptionsPriv = &contextOptionsPriv;
+    ctxOptions.fOptionsPriv->fStoreContextRefInRecorder = true;
+    fGraphiteContext =
+        skgpu::graphite::ContextFactory::MakeDawn(backendContext, ctxOptions);
+
+    if (!fGraphiteContext) {
+      throw std::runtime_error("Failed to create graphite context");
+    }
+  }
+
+  void tick() { backendContext.fTick(backendContext.fInstance); }
+
+  skgpu::graphite::Recorder *getRecorder() {
+    static thread_local skgpu::graphite::RecorderOptions recorderOptions;
+    if (!recorderOptions.fImageProvider) {
+      auto imageProvider = ImageProvider::Make();
+      recorderOptions.fImageProvider = imageProvider;
+    }
+    static thread_local auto recorder =
+        fGraphiteContext->makeRecorder(recorderOptions);
+    if (!recorder) {
+      throw std::runtime_error("Failed to create graphite context");
+    }
+    return recorder.get();
+  }
+};
+
+} // namespace RNSkia

package/cpp/rnskia/DawnUtils.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "dawn/dawn_proc.h"
+#include "dawn/native/DawnNative.h"
+
+#include "include/core/SkColorType.h"
+#include "include/gpu/graphite/dawn/DawnBackendContext.h"
+
+namespace DawnUtils {
+
+#ifdef __APPLE__
+static const SkColorType PreferedColorType = kBGRA_8888_SkColorType;
+static const wgpu::TextureFormat PreferredTextureFormat =
+    wgpu::TextureFormat::BGRA8Unorm;
+#else
+static const SkColorType PreferedColorType = kRGBA_8888_SkColorType;
+static const wgpu::TextureFormat PreferredTextureFormat =
+    wgpu::TextureFormat::RGBA8Unorm;
+#endif
+
+inline skgpu::graphite::DawnBackendContext
+createDawnBackendContext(dawn::native::Instance *instance) {
+
+  auto useTintIR = false;
+  static constexpr const char *kToggles[] = {
+      "allow_unsafe_apis",
+      "use_user_defined_labels_in_backend",
+      "disable_robustness",
+      "use_tint_ir",
+  };
+  wgpu::DawnTogglesDescriptor togglesDesc;
+  togglesDesc.enabledToggleCount = std::size(kToggles) - (useTintIR ? 0 : 1);
+  togglesDesc.enabledToggles = kToggles;
+
+  wgpu::RequestAdapterOptions options;
+#ifdef __APPLE__
+  constexpr auto kDefaultBackendType = wgpu::BackendType::Metal;
+#elif __ANDROID__
+  constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
+#endif
+  options.backendType = kDefaultBackendType;
+  options.nextInChain = &togglesDesc;
+
+  std::vector<dawn::native::Adapter> adapters =
+      instance->EnumerateAdapters(&options);
+  if (adapters.empty()) {
+    throw std::runtime_error("No matching adapter found");
+  }
+
+  wgpu::Adapter adapter = adapters[0].Get();
+
+  std::vector<wgpu::FeatureName> features;
+  if (adapter.HasFeature(wgpu::FeatureName::MSAARenderToSingleSampled)) {
+    features.push_back(wgpu::FeatureName::MSAARenderToSingleSampled);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::TransientAttachments)) {
+    features.push_back(wgpu::FeatureName::TransientAttachments);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::Unorm16TextureFormats)) {
+    features.push_back(wgpu::FeatureName::Unorm16TextureFormats);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::DualSourceBlending)) {
+    features.push_back(wgpu::FeatureName::DualSourceBlending);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::FramebufferFetch)) {
+    features.push_back(wgpu::FeatureName::FramebufferFetch);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::BufferMapExtendedUsages)) {
+    features.push_back(wgpu::FeatureName::BufferMapExtendedUsages);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionETC2)) {
+    features.push_back(wgpu::FeatureName::TextureCompressionETC2);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionBC)) {
+    features.push_back(wgpu::FeatureName::TextureCompressionBC);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::R8UnormStorage)) {
+    features.push_back(wgpu::FeatureName::R8UnormStorage);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::DawnLoadResolveTexture)) {
+    features.push_back(wgpu::FeatureName::DawnLoadResolveTexture);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::DawnPartialLoadResolveTexture)) {
+    features.push_back(wgpu::FeatureName::DawnPartialLoadResolveTexture);
+  }
+#ifdef __APPLE__
+  if (adapter.HasFeature(wgpu::FeatureName::SharedTextureMemoryIOSurface)) {
+    features.push_back(wgpu::FeatureName::SharedTextureMemoryIOSurface);
+  }
+#else
+  if (adapter.HasFeature(
+          wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer)) {
+    features.push_back(wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer);
+  }
+#endif
+
+  wgpu::DeviceDescriptor desc;
+  desc.requiredFeatureCount = features.size();
+  desc.requiredFeatures = features.data();
+  desc.nextInChain = &togglesDesc;
+  desc.SetDeviceLostCallback(
+      wgpu::CallbackMode::AllowSpontaneous,
+      [](const wgpu::Device &, wgpu::DeviceLostReason reason,
+         const char *message) {
+        if (reason != wgpu::DeviceLostReason::Destroyed) {
+          SK_ABORT("Device lost: %s\n", message);
+        }
+      });
+  desc.SetUncapturedErrorCallback(
+      [](const wgpu::Device &, wgpu::ErrorType, const char *message) {
+        SkDebugf("Device error: %s\n", message);
+      });
+
+  wgpu::Device device = adapter.CreateDevice(&desc);
+  SkASSERT(device);
+
+  skgpu::graphite::DawnBackendContext backendContext;
+  backendContext.fInstance = wgpu::Instance(instance->Get());
+  backendContext.fDevice = device;
+  backendContext.fQueue = device.GetQueue();
+
+  return backendContext;
+}
+
+} // namespace DawnUtils

package/cpp/rnskia/DawnWindowContext.cpp

@@ -0,0 +1,19 @@
+#include "DawnWindowContext.h"
+
+#include "DawnContext.h"
+
+namespace RNSkia {
+
+void DawnWindowContext::present() {
+  auto recording = _recorder->snap();
+  if (!recording) {
+    throw std::runtime_error("Failed to create graphite recording");
+  }
+  DawnContext::getInstance().submitRecording(recording.get());
+#ifdef __APPLE__
+  dawn::native::metal::WaitForCommandsToBeScheduled(_device.Get());
+#endif
+  _surface.Present();
+}
+
+} // namespace RNSkia