@shopify/react-native-skia 2.0.1 → 2.0.3

package/android/CMakeLists.txt

@@ -3,7 +3,53 @@ cmake_minimum_required(VERSION 3.4.1)
 
 set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 17)
-set(SK_GRAPHITE OFF)
+
+# Import prebuilt SKIA libraries path
+set (SKIA_LIBS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../libs/android/${ANDROID_ABI}")
+
+# Import libskia first so we can check for symbols
+add_library(skia STATIC IMPORTED)
+set_property(TARGET skia PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskia.a")
+
+# Check if Graphite symbols are available in libskia using nm/objdump
+set(SK_GRAPHITE_AVAILABLE OFF)
+
+if(EXISTS "${SKIA_LIBS_PATH}/libskia.a")
+    # Look for specific Dawn function symbols that indicate Graphite support
+    execute_process(
+        COMMAND nm "${SKIA_LIBS_PATH}/libskia.a"
+        COMMAND grep "dawn::\\|wgpu\\|_ZN4dawn\\|DawnDevice\\|dawn_native"
+        OUTPUT_VARIABLE NM_OUTPUT
+        ERROR_QUIET
+        RESULT_VARIABLE NM_RESULT
+    )
+    
+    if(NM_RESULT EQUAL 0 AND NOT "${NM_OUTPUT}" STREQUAL "")
+        set(SK_GRAPHITE_AVAILABLE ON)
+    else()
+        # Fallback to objdump if nm doesn't work
+        execute_process(
+            COMMAND objdump -t "${SKIA_LIBS_PATH}/libskia.a"
+            COMMAND grep "dawn::\\|wgpu\\|_ZN4dawn\\|DawnDevice\\|dawn_native"
+            OUTPUT_VARIABLE OBJDUMP_OUTPUT
+            ERROR_QUIET
+            RESULT_VARIABLE OBJDUMP_RESULT
+        )
+        
+        if(OBJDUMP_RESULT EQUAL 0 AND NOT "${OBJDUMP_OUTPUT}" STREQUAL "")
+            set(SK_GRAPHITE_AVAILABLE ON)
+        endif()
+    endif()
+endif()
+
+if(SK_GRAPHITE_AVAILABLE)
+    set(SK_GRAPHITE ON)
+    message("-- SK_GRAPHITE: ON (Graphite symbols found in libskia)")
+else()
+    set(SK_GRAPHITE OFF)
+    message("-- SK_GRAPHITE: OFF (Graphite symbols not found in libskia)")
+endif()
+
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSK_BUILD_FOR_ANDROID -DSK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_HAVE_MEMRCHR=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_MOBILE=1 -DON_ANDROID -DONANDROID")
 set (PACKAGE_NAME "rnskia")
 set (SKIA_LIB "skia")
@@ -31,26 +77,12 @@ message("-- LIBRN   : " ${LIBRN_DIR})
 
 link_directories(../libs/android/${ANDROID_ABI}/)
 
-# Import prebuilt SKIA libraries
-set (SKIA_LIBS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../libs/android/${ANDROID_ABI}")
-
 if(SK_GRAPHITE)
     add_definitions(-DSK_GRAPHITE)
-    set(DAWN_NATIVE_LIB "libdawn_native_static")
-    set(DAWN_PLATFORM_LIB "libdawn_platform_static")
-    set(DAWN_PROC_LIB "libdawn_proc_static")
     set(BACKEND_SOURCES
     #TODO: is this source needed to be added?
         "${PROJECT_SOURCE_DIR}/../cpp/rnskia/DawnWindowContext.cpp"
     )
-    add_library(libdawn_native_static STATIC IMPORTED)
-    set_property(TARGET libdawn_native_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_native_static.a")
-
-    add_library(libdawn_platform_static STATIC IMPORTED)
-    set_property(TARGET libdawn_platform_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_platform_static.a")
-
-    add_library(libdawn_proc_static STATIC IMPORTED)
-    set_property(TARGET libdawn_proc_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_proc_static.a")
 else()
     add_definitions(-DSK_GL -DSK_GANESH)
     set(BACKEND_SOURCES
@@ -122,9 +154,6 @@ target_include_directories(
         ${libfbjni_include_DIRS}
 )
 
-add_library(skia STATIC IMPORTED)
-set_property(TARGET skia PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskia.a")
-
 add_library(svg STATIC IMPORTED)
 set_property(TARGET svg PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libsvg.a")
 
@@ -298,9 +327,6 @@ endif()
 if(SK_GRAPHITE)
     target_link_libraries(${PACKAGE_NAME}
         ${COMMON_LIBS}
-        ${DAWN_NATIVE_LIB}
-        ${DAWN_PLATFORM_LIB}
-        ${DAWN_PROC_LIB}
     )
 else()
     target_link_libraries(${PACKAGE_NAME}

package/android/cpp/rnskia-android/RNSkAndroidPlatformContext.h

@@ -75,6 +75,7 @@ public:
 #endif
   }
 
+#if !defined(SK_GRAPHITE)
   sk_sp<SkImage> makeImageFromNativeTexture(const TextureInfo &texInfo,
                                             int width, int height,
                                             bool mipMapped) override {
@@ -99,6 +100,7 @@ public:
         kTopLeft_GrSurfaceOrigin, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType,
         nullptr);
   }
+#endif
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override {
     auto jniVideo = _jniPlatformContext->createVideo(url);
@@ -171,6 +173,11 @@ public:
 #endif
   }
 
+#if !defined(SK_GRAPHITE)
+  GrDirectContext *getDirectContext() override {
+    return OpenGLContext::getInstance().getDirectContext();
+  }
+
   const TextureInfo getTexture(sk_sp<SkImage> image) override {
     GrBackendTexture texture;
     if (!SkImages::GetBackendTextureFromImage(image, &texture, true)) {
@@ -186,6 +193,7 @@ public:
   }
 
   static TextureInfo getTextureInfo(const GrBackendTexture &texture) {
+
     if (!texture.isValid()) {
       throw std::runtime_error("invalid backend texture");
     }
@@ -204,11 +212,6 @@ public:
     texInfo.glTarget = textureInfo.fTarget;
     return texInfo;
   }
-
-#if !defined(SK_GRAPHITE)
-  GrDirectContext *getDirectContext() override {
-    return OpenGLContext::getInstance().getDirectContext();
-  }
 #endif
 
   sk_sp<SkFontMgr> createFontMgr() override {

package/apple/MetalWindowContext.mm

@@ -25,10 +25,12 @@ MetalWindowContext::MetalWindowContext(GrDirectContext *directContext,
   _layer.drawableSize = CGSizeMake(width, height);
   BOOL supportsWideColor = NO;
   if (@available(iOS 10.0, *)) {
-    supportsWideColor = [UIScreen mainScreen].traitCollection.displayGamut == UIDisplayGamutP3;
+    supportsWideColor =
+        [UIScreen mainScreen].traitCollection.displayGamut == UIDisplayGamutP3;
   }
   if (supportsWideColor) {
-    CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3);
+    CGColorSpaceRef colorSpace =
+        CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3);
     _layer.colorspace = colorSpace;
     CGColorSpaceRelease(colorSpace);
   }

package/apple/RNSkApplePlatformContext.h

@@ -43,15 +43,19 @@ public:
 
   sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override;
 
+#if !defined(SK_GRAPHITE)
+  GrDirectContext *getDirectContext() override;
+
   sk_sp<SkImage> makeImageFromNativeTexture(const TextureInfo &textureInfo,
                                             int width, int height,
                                             bool mipMapped) override;
 
-  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override;
-
   const TextureInfo getTexture(sk_sp<SkSurface> image) override;
 
   const TextureInfo getTexture(sk_sp<SkImage> image) override;
+#endif
+
+  uint64_t makeNativeBuffer(sk_sp<SkImage> image) override;
 
   void releaseNativeBuffer(uint64_t pointer) override;
 
@@ -66,9 +70,7 @@ public:
 
   void raiseError(const std::exception &err) override;
   sk_sp<SkSurface> makeOffscreenSurface(int width, int height) override;
-#if !defined(SK_GRAPHITE)
-  GrDirectContext *getDirectContext() override;
-#endif
+
   sk_sp<SkFontMgr> createFontMgr() override;
 
 private:

package/apple/RNSkApplePlatformContext.mm

@@ -156,9 +156,14 @@ uint64_t RNSkApplePlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
   return reinterpret_cast<uint64_t>(pixelBuffer);
 }
 
+#if !defined(SK_GRAPHITE)
+GrDirectContext *RNSkApplePlatformContext::getDirectContext() {
+  return MetalContext::getInstance().getDirectContext();
+}
+
 const TextureInfo RNSkApplePlatformContext::getTexture(sk_sp<SkImage> image) {
-  GrBackendTexture texture;
   TextureInfo result;
+  GrBackendTexture texture;
   if (!SkImages::GetBackendTextureFromImage(image, &texture, true)) {
     throw std::runtime_error("Couldn't get backend texture");
   }
@@ -175,9 +180,9 @@ const TextureInfo RNSkApplePlatformContext::getTexture(sk_sp<SkImage> image) {
 
 const TextureInfo
 RNSkApplePlatformContext::getTexture(sk_sp<SkSurface> surface) {
+  TextureInfo result;
   GrBackendTexture texture = SkSurfaces::GetBackendTexture(
       surface.get(), SkSurfaces::BackendHandleAccess::kFlushRead);
-  TextureInfo result;
   if (!texture.isValid()) {
     throw std::runtime_error("Invalid backend texture");
   }
@@ -189,6 +194,29 @@ RNSkApplePlatformContext::getTexture(sk_sp<SkSurface> surface) {
   return result;
 }
 
+sk_sp<SkImage> RNSkApplePlatformContext::makeImageFromNativeTexture(
+    const TextureInfo &texInfo, int width, int height, bool mipMapped) {
+  id<MTLTexture> mtlTexture = (__bridge id<MTLTexture>)(texInfo.mtlTexture);
+
+  SkColorType colorType = mtlPixelFormatToSkColorType(mtlTexture.pixelFormat);
+  if (colorType == SkColorType::kUnknown_SkColorType) {
+    throw std::runtime_error("Unsupported pixelFormat");
+  }
+
+  GrMtlTextureInfo textureInfo;
+  textureInfo.fTexture.retain((__bridge const void *)mtlTexture);
+
+  GrBackendTexture texture = GrBackendTextures::MakeMtl(
+      width, height, mipMapped ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo,
+      textureInfo);
+
+  return SkImages::BorrowTextureFrom(getDirectContext(), texture,
+                                     kTopLeft_GrSurfaceOrigin, colorType,
+                                     kPremul_SkAlphaType, nullptr);
+  return nullptr;
+}
+#endif
+
 std::shared_ptr<RNSkVideo>
 RNSkApplePlatformContext::createVideo(const std::string &url) {
   return std::make_shared<RNSkAppleVideo>(url, this);
@@ -227,27 +255,6 @@ RNSkApplePlatformContext::makeImageFromNativeBuffer(void *buffer) {
 #endif
 }
 
-sk_sp<SkImage> RNSkApplePlatformContext::makeImageFromNativeTexture(
-    const TextureInfo &texInfo, int width, int height, bool mipMapped) {
-  id<MTLTexture> mtlTexture = (__bridge id<MTLTexture>)(texInfo.mtlTexture);
-
-  SkColorType colorType = mtlPixelFormatToSkColorType(mtlTexture.pixelFormat);
-  if (colorType == SkColorType::kUnknown_SkColorType) {
-    throw std::runtime_error("Unsupported pixelFormat");
-  }
-
-  GrMtlTextureInfo textureInfo;
-  textureInfo.fTexture.retain((__bridge const void *)mtlTexture);
-
-  GrBackendTexture texture = GrBackendTextures::MakeMtl(
-      width, height, mipMapped ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo,
-      textureInfo);
-
-  return SkImages::BorrowTextureFrom(getDirectContext(), texture,
-                                     kTopLeft_GrSurfaceOrigin, colorType,
-                                     kPremul_SkAlphaType, nullptr);
-}
-
 SkColorType RNSkApplePlatformContext::mtlPixelFormatToSkColorType(
     MTLPixelFormat pixelFormat) {
   switch (pixelFormat) {
@@ -280,12 +287,6 @@ SkColorType RNSkApplePlatformContext::mtlPixelFormatToSkColorType(
   }
 }
 
-#if !defined(SK_GRAPHITE)
-GrDirectContext *RNSkApplePlatformContext::getDirectContext() {
-  return MetalContext::getInstance().getDirectContext();
-}
-#endif
-
 sk_sp<SkFontMgr> RNSkApplePlatformContext::createFontMgr() {
   return SkFontMgr_New_CoreText(nullptr);
 }

package/apple/SkiaCVPixelBufferUtils.mm

@@ -30,16 +30,12 @@
 #include <TargetConditionals.h>
 #if TARGET_RT_BIG_ENDIAN
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]) {                                                             \
-    *((char *)&fourcc), *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 2),    \
-        *(((char *)&fourcc) + 3), 0                                            \
-  }
+  (const char[]){*((char *)&fourcc), *(((char *)&fourcc) + 1),                 \
+                 *(((char *)&fourcc) + 2), *(((char *)&fourcc) + 3), 0}
 #else
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]) {                                                             \
-    *(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),                        \
-        *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0                  \
-  }
+  (const char[]){*(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),           \
+                 *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0}
 #endif
 
 // pragma MARK: TextureHolder

package/apple/SkiaManager.mm

@@ -20,9 +20,6 @@ static __weak SkiaManager *sharedInstance = nil;
 }
 
 - (void)invalidate {
-  if (_skManager != nullptr) {
-    _skManager->invalidate();
-  }
   _skManager = nullptr;
 }
 

package/cpp/api/JsiSkImageFactory.h

@@ -17,6 +17,11 @@ namespace jsi = facebook::jsi;
 
 class JsiSkImageFactory : public JsiSkHostObject {
 public:
+  JSI_HOST_FUNCTION(MakeNull) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkImage>(getContext(), nullptr));
+  }
+
   JSI_HOST_FUNCTION(MakeImageFromEncoded) {
     auto data = JsiSkData::fromValue(runtime, arguments[0]);
     auto image = SkImages::DeferredFromEncodedData(data);
@@ -86,6 +91,13 @@ public:
     if (image == nullptr) {
       throw std::runtime_error("Failed to convert native texture to SkImage!");
     }
+    if (count > 4 && arguments[4].isObject() &&
+        arguments[4].asObject(runtime).isHostObject(runtime)) {
+      auto jsiImage =
+          arguments[4].asObject(runtime).asHostObject<JsiSkImage>(runtime);
+      jsiImage->setObject(image);
+      return jsi::Value(runtime, arguments[4]);
+    }
     return jsi::Object::createFromHostObject(
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }
@@ -96,7 +108,8 @@ public:
                                        MakeImageFromNativeBuffer),
                        JSI_EXPORT_FUNC(JsiSkImageFactory,
                                        MakeImageFromNativeTextureUnstable),
-                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImage))
+                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeImage),
+                       JSI_EXPORT_FUNC(JsiSkImageFactory, MakeNull))
 
   explicit JsiSkImageFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/JsiSkSurface.h

@@ -64,7 +64,7 @@ public:
   JSI_HOST_FUNCTION(makeImageSnapshot) {
     auto surface = getObject();
     sk_sp<SkImage> image;
-    if (count == 1) {
+    if (count > 0 && arguments[0].isObject()) {
       auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
       image = surface->makeImageSnapshot(SkIRect::MakeXYWH(
           rect->x(), rect->y(), rect->width(), rect->height()));
@@ -75,6 +75,12 @@ public:
     auto recording = surface->recorder()->snap();
     DawnContext::getInstance().submitRecording(recording.get());
 #endif
+    if (count > 1 && arguments[1].isObject()) {
+      auto jsiImage =
+          arguments[1].asObject(runtime).asHostObject<JsiSkImage>(runtime);
+      jsiImage->setObject(image);
+      return jsi::Value(runtime, arguments[1]);
+    }
     return jsi::Object::createFromHostObject(
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
   }

package/cpp/api/recorder/DrawingCtx.h

@@ -56,11 +56,24 @@ public:
     SkPaint paint;
     paint.setAntiAlias(true);
     paints.push_back(paint);
+    opacities.push_back(1.0f);
   }
 
-  void pushPaint(SkPaint &paint) { paints.push_back(paint); }
+  float getOpacity() const { return opacities.back(); }
+  
+  void setOpacity(float newOpacity) {
+    opacities.back() = std::clamp(newOpacity, 0.0f, 1.0f);
+  }
+
+  void pushPaint(SkPaint &paint) { 
+    paints.push_back(paint);
+    opacities.push_back(opacities.back());
+  }
 
-  void savePaint() { paints.push_back(SkPaint(getPaint())); }
+  void savePaint() { 
+    paints.push_back(SkPaint(getPaint()));
+    opacities.push_back(opacities.back());
+  }
 
   void saveBackdropFilter() {
     // Initialize image filter as nullptr
@@ -96,6 +109,7 @@ public:
     }
     auto paint = paints.back();
     paints.pop_back();
+    opacities.pop_back();
     return paint;
   }
 
@@ -182,6 +196,9 @@ public:
   std::vector<sk_sp<SkImageFilter>> imageFilters;
   std::vector<sk_sp<SkPathEffect>> pathEffects;
   std::vector<SkPaint> paintDeclarations;
+
+private:
+  std::vector<float> opacities;
 };
 
 } // namespace RNSkia

package/cpp/api/recorder/Paint.h

@@ -153,13 +153,11 @@ public:
     ctx->savePaint();
     auto &paint = ctx->getPaint();
     if (props.opacity.has_value()) {
-      paint.setAlphaf(paint.getAlphaf() * props.opacity.value());
+      ctx->setOpacity(ctx->getOpacity() * props.opacity.value());
     }
     if (props.color.has_value()) {
-      auto currentOpacity = paint.getAlphaf();
       paint.setShader(nullptr);
       paint.setColor(props.color.value());
-      paint.setAlphaf(currentOpacity * paint.getAlphaf());
     }
     if (props.blendMode.has_value()) {
       paint.setBlendMode(props.blendMode.value());

package/cpp/api/recorder/RNRecorder.h

@@ -294,7 +294,7 @@ public:
   void play(DrawingCtx *ctx) {
     for (const auto &cmd : commands) {
       switch (cmd->type) {
-
+			  
       case Group: {
         // Do nothing here for now
         break;
@@ -483,17 +483,6 @@ public:
         break;
       }
 
-      case CommandType::DrawPaint: {
-        ctx->canvas->drawPaint(ctx->getPaint());
-        break;
-      }
-
-      case CommandType::DrawText: {
-        auto *textCmd = static_cast<TextCmd *>(cmd.get());
-        textCmd->draw(ctx);
-        break;
-      }
-
       case CommandType::RestorePaint: {
         ctx->restorePaint();
         break;
@@ -512,7 +501,10 @@ public:
       default: {
         // Handle all drawing commands
         auto currentPaints = ctx->paintDeclarations;
-        currentPaints.push_back(ctx->getPaint()); // Add current paint
+        // apply alpha to the current paint.
+        SkPaint paint(ctx->getPaint());
+        paint.setAlphaf(paint.getAlphaf() * ctx->getOpacity());
+        currentPaints.push_back(paint);
         ctx->paintDeclarations.clear();
 
         for (auto &paint : currentPaints) {

package/cpp/rnskia/DawnContext.h

@@ -204,7 +204,7 @@ private:
     DawnProcTable backendProcs = dawn::native::GetProcs();
     dawnProcSetProcs(&backendProcs);
     WGPUInstanceDescriptor desc{};
-    desc.features.timedWaitAnyEnable = true;
+    desc.capabilities.timedWaitAnyEnable = true;
     instance = std::make_unique<dawn::native::Instance>(&desc);
 
     backendContext = DawnUtils::createDawnBackendContext(instance.get());
@@ -221,7 +221,16 @@ private:
     }
   }
 
-  void tick() { backendContext.fTick(backendContext.fInstance); }
+  ~DawnContext() {
+    backendContext.fDevice = nullptr;
+    tick();
+  }
+
+  void tick() {
+    if (backendContext.fTick) {
+      backendContext.fTick(backendContext.fInstance);
+    }
+  }
 
   skgpu::graphite::Recorder *getRecorder() {
     static thread_local skgpu::graphite::RecorderOptions recorderOptions;

package/cpp/rnskia/DawnUtils.h

@@ -5,6 +5,7 @@
 #include "dawn/dawn_proc.h"
 #include "dawn/native/DawnNative.h"
 
+#include "RNSkLog.h"
 #include "include/core/SkColorType.h"
 #include "include/gpu/graphite/dawn/DawnBackendContext.h"
 
@@ -25,6 +26,10 @@ createDawnBackendContext(dawn::native::Instance *instance) {
 
   auto useTintIR = false;
   static constexpr const char *kToggles[] = {
+#if !defined(SK_DEBUG)
+      "skip_validation",
+#endif
+      "disable_lazy_clear_for_mapped_at_creation_buffer",
       "allow_unsafe_apis",
       "use_user_defined_labels_in_backend",
       "disable_robustness",
@@ -34,6 +39,8 @@ createDawnBackendContext(dawn::native::Instance *instance) {
   togglesDesc.enabledToggleCount = std::size(kToggles) - (useTintIR ? 0 : 1);
   togglesDesc.enabledToggles = kToggles;
 
+  dawn::native::Adapter matchedAdaptor;
+
   wgpu::RequestAdapterOptions options;
 #ifdef __APPLE__
   constexpr auto kDefaultBackendType = wgpu::BackendType::Metal;
@@ -41,6 +48,7 @@ createDawnBackendContext(dawn::native::Instance *instance) {
   constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
 #endif
   options.backendType = kDefaultBackendType;
+  options.featureLevel = wgpu::FeatureLevel::Core;
   options.nextInChain = &togglesDesc;
 
   std::vector<dawn::native::Adapter> adapters =
@@ -49,7 +57,78 @@ createDawnBackendContext(dawn::native::Instance *instance) {
     throw std::runtime_error("No matching adapter found");
   }
 
-  wgpu::Adapter adapter = adapters[0].Get();
+  // Sort adapters by adapterType(DiscreteGPU, IntegratedGPU, CPU) and
+  // backendType(Metal, Vulkan, OpenGL, OpenGLES, WebGPU).
+  std::sort(adapters.begin(), adapters.end(),
+            [](dawn::native::Adapter a, dawn::native::Adapter b) {
+              wgpu::Adapter wgpuA = a.Get();
+              wgpu::Adapter wgpuB = b.Get();
+              wgpu::AdapterInfo infoA;
+              wgpu::AdapterInfo infoB;
+              wgpuA.GetInfo(&infoA);
+              wgpuB.GetInfo(&infoB);
+              return std::tuple(infoA.adapterType, infoA.backendType) <
+                     std::tuple(infoB.adapterType, infoB.backendType);
+            });
+
+  for (const auto &adapter : adapters) {
+    wgpu::Adapter wgpuAdapter = adapter.Get();
+    wgpu::AdapterInfo props;
+    wgpuAdapter.GetInfo(&props);
+    if (kDefaultBackendType == props.backendType) {
+      matchedAdaptor = adapter;
+      break;
+    }
+  }
+
+  if (!matchedAdaptor) {
+    throw std::runtime_error("No matching adapter found");
+  }
+
+  wgpu::Adapter adapter = matchedAdaptor.Get();
+
+  // Log selected adapter info
+  wgpu::AdapterInfo adapterInfo;
+  adapter.GetInfo(&adapterInfo);
+  std::string deviceName =
+      adapterInfo.device.data
+          ? std::string(adapterInfo.device.data, adapterInfo.device.length)
+          : "Unknown";
+  std::string description = adapterInfo.description.data
+                                ? std::string(adapterInfo.description.data,
+                                              adapterInfo.description.length)
+                                : "Unknown";
+
+  std::string backendName;
+  switch (adapterInfo.backendType) {
+  case wgpu::BackendType::Metal:
+    backendName = "Metal";
+    break;
+  case wgpu::BackendType::Vulkan:
+    backendName = "Vulkan";
+    break;
+  case wgpu::BackendType::OpenGL:
+    backendName = "OpenGL";
+    break;
+  case wgpu::BackendType::OpenGLES:
+    backendName = "OpenGLES";
+    break;
+  case wgpu::BackendType::WebGPU:
+    backendName = "WebGPU";
+    break;
+  case wgpu::BackendType::Null:
+    backendName = "Null";
+    break;
+  default:
+    backendName = "Undefined (" +
+                  std::to_string(static_cast<int>(adapterInfo.backendType)) +
+                  ")";
+    break;
+  }
+
+  RNSkia::RNSkLogger::logToConsole(
+      "Selected Dawn adapter - Backend: %s, Device: %s, Description: %s",
+      backendName.c_str(), deviceName.c_str(), description.c_str());
 
   std::vector<wgpu::FeatureName> features;
   if (adapter.HasFeature(wgpu::FeatureName::MSAARenderToSingleSampled)) {
@@ -85,6 +164,15 @@ createDawnBackendContext(dawn::native::Instance *instance) {
   if (adapter.HasFeature(wgpu::FeatureName::DawnPartialLoadResolveTexture)) {
     features.push_back(wgpu::FeatureName::DawnPartialLoadResolveTexture);
   }
+  if (adapter.HasFeature(wgpu::FeatureName::TimestampQuery)) {
+    features.push_back(wgpu::FeatureName::TimestampQuery);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::DawnTexelCopyBufferRowAlignment)) {
+    features.push_back(wgpu::FeatureName::DawnTexelCopyBufferRowAlignment);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::ImplicitDeviceSynchronization)) {
+    features.push_back(wgpu::FeatureName::ImplicitDeviceSynchronization);
+  }
 #ifdef __APPLE__
   if (adapter.HasFeature(wgpu::FeatureName::SharedTextureMemoryIOSurface)) {
     features.push_back(wgpu::FeatureName::SharedTextureMemoryIOSurface);
@@ -103,17 +191,20 @@ createDawnBackendContext(dawn::native::Instance *instance) {
   desc.SetDeviceLostCallback(
       wgpu::CallbackMode::AllowSpontaneous,
       [](const wgpu::Device &, wgpu::DeviceLostReason reason,
-         const char *message) {
+         wgpu::StringView message) {
         if (reason != wgpu::DeviceLostReason::Destroyed) {
-          SK_ABORT("Device lost: %s\n", message);
+          SK_ABORT("Device lost: %.*s\n", static_cast<int>(message.length),
+                   message.data);
         }
       });
   desc.SetUncapturedErrorCallback(
-      [](const wgpu::Device &, wgpu::ErrorType, const char *message) {
-        SkDebugf("Device error: %s\n", message);
+      [](const wgpu::Device &, wgpu::ErrorType, wgpu::StringView message) {
+        SkDebugf("Device error: %.*s\n", static_cast<int>(message.length),
+                 message.data);
       });
 
-  wgpu::Device device = adapter.CreateDevice(&desc);
+  wgpu::Device device =
+      wgpu::Device::Acquire(matchedAdaptor.CreateDevice(&desc));
   SkASSERT(device);
 
   skgpu::graphite::DawnBackendContext backendContext;