react-native-skia 3.0.1 → 3.0.2

package/android/src/main/java/com/reactnative/skia/{SkiaBaseView.java → SkiaView.java}

@@ -3,18 +3,33 @@ package com.reactnative.skia;
 import android.content.Context;
 import android.graphics.SurfaceTexture;
 import android.util.Log;
+import android.view.Choreographer;
 import android.view.MotionEvent;
 import android.view.Surface;
 import android.view.View;
 
+import com.facebook.jni.HybridData;
+import com.facebook.jni.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.uimanager.PointerEvents;
 import com.facebook.react.views.view.ReactViewGroup;
 
-public abstract class SkiaBaseView extends ReactViewGroup implements SkiaViewAPI {
+/**
+ * The Android view behind <Canvas>, <SkiaPictureView> and <SkiaGraphiteView>.
+ * It is backed by a SurfaceView or a TextureView (see updateView()) that the
+ * native side draws into with Graphite, presenting the queued recordings on
+ * the Choreographer.
+ */
+public class SkiaView extends ReactViewGroup implements SkiaViewAPI, Choreographer.FrameCallback {
     // Backing view kinds, see updateView().
     private static final int KIND_SURFACE_VIEW = 0;
     private static final int KIND_TEXTURE_VIEW = 1;
 
+    private static final String TAG = "SkiaView";
+
+    @DoNotStrip
+    private HybridData mHybridData;
+
     private View mView;
 
     // Props, applied together in updateView().
@@ -28,11 +43,12 @@ public abstract class SkiaBaseView extends ReactViewGroup implements SkiaViewAPI
     private boolean mAppliedZOrderOnTop;
     private boolean mAppliedHighBitDepth;
 
-    private final boolean debug = false;
-    private final String tag = "SkiaView";
+    private boolean mFramePending = false;
 
-    public SkiaBaseView(Context context) {
+    public SkiaView(Context context) {
         super(context);
+        RNSkiaModule skiaModule = ((ReactContext) context).getNativeModule(RNSkiaModule.class);
+        mHybridData = initHybrid(skiaModule.getSkiaManager());
     }
 
     @Override
@@ -82,7 +98,7 @@ public abstract class SkiaBaseView extends ReactViewGroup implements SkiaViewAPI
             return false;
         }
         if (kind != KIND_SURFACE_VIEW || !mOpaque) {
-            Log.w(tag, "highBitDepth requires an opaque SurfaceView on Android, falling back to the 8-bit format");
+            Log.w(TAG, "highBitDepth requires an opaque SurfaceView on Android, falling back to the 8-bit format");
             return false;
         }
         return true;
@@ -107,8 +123,8 @@ public abstract class SkiaBaseView extends ReactViewGroup implements SkiaViewAPI
             mAppliedZOrderOnTop = zOrderOnTop;
             mAppliedHighBitDepth = highBitDepth;
             mView = kind == KIND_SURFACE_VIEW
-                    ? new SkiaSurfaceView(getContext(), this, debug, zOrderOnTop, mOpaque)
-                    : new SkiaTextureView(getContext(), this, debug, mOpaque);
+                    ? new SkiaSurfaceView(getContext(), this, zOrderOnTop, mOpaque)
+                    : new SkiaTextureView(getContext(), this, mOpaque);
             addView(mView);
             // React Native sizes native children explicitly through onLayout, so
             // the requestLayout triggered by addView is ignored; size the new
@@ -130,11 +146,52 @@ public abstract class SkiaBaseView extends ReactViewGroup implements SkiaViewAPI
     @Override
     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
         super.onLayout(changed, left, top, right, bottom);
+        // The backing view gets this exact size, and so does its surface: tell
+        // the native side now, so that a frame recorded before the surface
+        // exists (the first one usually is) already has the right size.
+        setLayoutSize(right - left, bottom - top);
         if (mView != null) {
             mView.layout(0, 0, right - left, bottom - top);
         }
     }
 
+    // Frames --------------------------------------------------------------
+
+    /**
+     * Presents the queued recordings on the next vsync. Main thread; called
+     * from native when a recording is submitted.
+     */
+    @DoNotStrip
+    public void scheduleFrame() {
+        if (!mFramePending) {
+            mFramePending = true;
+            Choreographer.getInstance().postFrameCallback(this);
+        }
+    }
+
+    @Override
+    public void doFrame(long frameTimeNanos) {
+        mFramePending = false;
+        if (presentFrame()) {
+            scheduleFrame();
+        }
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        Choreographer.getInstance().removeFrameCallback(this);
+        mFramePending = false;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+        mHybridData.resetNative();
+    }
+
+    // Surfaces ------------------------------------------------------------
+
     // SurfaceView callbacks: the native side receives an android.view.Surface.
 
     @Override
@@ -144,7 +201,7 @@ public abstract class SkiaBaseView extends ReactViewGroup implements SkiaViewAPI
 
     @Override
     public void onSurfaceChanged(Surface surface, int width, int height) {
-        Log.i(tag, "onSurfaceChanged " + width + "/" + height);
+        Log.i(TAG, "onSurfaceChanged " + width + "/" + height);
         surfaceSizeChanged(surface, width, height, true, mAppliedHighBitDepth);
     }
 
@@ -158,7 +215,7 @@ public abstract class SkiaBaseView extends ReactViewGroup implements SkiaViewAPI
 
     @Override
     public void onSurfaceTextureChanged(SurfaceTexture surface, int width, int height) {
-        Log.i(tag, "onSurfaceTextureSizeChanged " + width + "/" + height);
+        Log.i(TAG, "onSurfaceTextureSizeChanged " + width + "/" + height);
         surfaceSizeChanged(surface, width, height, false, false);
     }
 
@@ -167,19 +224,24 @@ public abstract class SkiaBaseView extends ReactViewGroup implements SkiaViewAPI
         surfaceDestroyed();
     }
 
+    // Native ---------------------------------------------------------------
+
+    private native HybridData initHybrid(SkiaManager skiaManager);
+
     // isSurface tells the native side whether `surface` is an
     // android.view.Surface (SurfaceView) or a SurfaceTexture (TextureView).
-    protected abstract void surfaceAvailable(Object surface, int width, int height, boolean isSurface, boolean highBitDepth);
+    private native void surfaceAvailable(Object surface, int width, int height, boolean isSurface, boolean highBitDepth);
 
-    protected abstract void surfaceSizeChanged(Object surface, int width, int height, boolean isSurface, boolean highBitDepth);
+    private native void surfaceSizeChanged(Object surface, int width, int height, boolean isSurface, boolean highBitDepth);
 
-    protected abstract void surfaceDestroyed();
+    private native void surfaceDestroyed();
 
-    protected abstract void setDebugMode(boolean show);
+    private native void setLayoutSize(int width, int height);
 
-    protected abstract void registerView(int nativeId);
+    native void registerView(int nativeId);
 
-    protected abstract void unregisterView();
+    private native void unregisterView();
 
-    protected abstract int[] getBitmap(int width, int height);
+    /** Choreographer tick: returns whether more recordings are waiting. */
+    private native boolean presentFrame();
 }

package/android/src/main/java/com/reactnative/skia/SkiaViewManager.java

@@ -0,0 +1,85 @@
+package com.reactnative.skia;
+
+import com.facebook.react.uimanager.PointerEvents;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewProps;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.viewmanagers.SkiaViewManagerDelegate;
+import com.facebook.react.viewmanagers.SkiaViewManagerInterface;
+import com.facebook.react.views.view.ReactViewGroup;
+import com.facebook.react.views.view.ReactViewManager;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public class SkiaViewManager extends ReactViewManager implements SkiaViewManagerInterface<SkiaView> {
+
+    protected SkiaViewManagerDelegate mDelegate;
+
+    SkiaViewManager() {
+        mDelegate = new SkiaViewManagerDelegate(this);
+    }
+
+    protected SkiaViewManagerDelegate getDelegate() {
+        return mDelegate;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "SkiaView";
+    }
+
+    @NonNull
+    @Override
+    public SkiaView createViewInstance(@NonNull ThemedReactContext reactContext) {
+        return new SkiaView(reactContext);
+    }
+
+    @Override
+    public void setNativeId(@NonNull ReactViewGroup view, @Nullable String nativeId) {
+        super.setNativeId(view, nativeId);
+        int nativeIdResolved = Integer.parseInt(nativeId);
+        ((SkiaView) view).registerView(nativeIdResolved);
+    }
+
+    @ReactProp(name = "opaque")
+    public void setOpaque(SkiaView view, boolean value) {
+        view.setOpaque(value);
+    }
+
+    @ReactProp(name = "highBitDepth")
+    public void setHighBitDepth(SkiaView view, boolean value) {
+        view.setHighBitDepth(value);
+    }
+
+    @ReactProp(name = "androidSurfaceType")
+    public void setAndroidSurfaceType(SkiaView view, @Nullable String value) {
+        view.setSurfaceType(value);
+    }
+
+    @ReactProp(name = "androidZOrderOnTop")
+    public void setAndroidZOrderOnTop(SkiaView view, boolean value) {
+        view.setZOrderOnTop(value);
+    }
+
+    @ReactProp(name = ViewProps.POINTER_EVENTS)
+    public void setPointerEvents(SkiaView view, @Nullable String pointerEventsStr) {
+        view.setPointerEvents(PointerEvents.parsePointerEvents(pointerEventsStr));
+    }
+
+    // The backing view depends on several props (opaque, androidSurfaceType,
+    // androidZOrderOnTop, highBitDepth), so it is resolved once per transaction
+    // rather than in each setter.
+    @Override
+    protected void onAfterUpdateTransaction(@NonNull ReactViewGroup view) {
+        super.onAfterUpdateTransaction(view);
+        ((SkiaView) view).updateView();
+    }
+
+    @Override
+    public void onDropViewInstance(@NonNull ReactViewGroup view) {
+        super.onDropViewInstance(view);
+        ((SkiaView) view).dropInstance();
+    }
+}

package/apple/MetalLayerColorSpace.mm

@@ -1,5 +1,3 @@
-#ifdef SK_GRAPHITE
-
 #import <CoreGraphics/CoreGraphics.h>
 #import <Foundation/Foundation.h>
 #import <QuartzCore/CAMetalLayer.h>
@@ -35,5 +33,3 @@ void applyCAMetalLayerColorSpace(void *nativeSurface,
 }
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE

package/apple/RNSkApplePlatformContext.h

@@ -42,18 +42,6 @@ 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;
-
-  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;
 
   uint64_t makeTestNativeBuffer(int width, int height) override;
@@ -78,8 +66,6 @@ public:
 
 private:
   ViewScreenshotService *_screenshotService;
-
-  SkColorType mtlPixelFormatToSkColorType(MTLPixelFormat pixelFormat);
 };
 
 } // namespace RNSkia

package/apple/RNSkApplePlatformContext.mm

@@ -1,18 +1,13 @@
 #import "RNSkApplePlatformContext.h"
 
 #import <CoreMedia/CMSampleBuffer.h>
-#include <Metal/Metal.h>
 #import <React/RCTUtils.h>
 #include <algorithm>
 #include <set>
 #include <thread>
 #include <utility>
 
-#if defined(SK_GRAPHITE)
 #include "RNDawnContext.h"
-#else
-#include "MetalContext.h"
-#endif
 #include "RNSkAppleVideo.h"
 
 #pragma clang diagnostic push
@@ -83,15 +78,12 @@ void RNSkApplePlatformContext::releaseNativeBuffer(uint64_t pointer) {
 }
 
 uint64_t RNSkApplePlatformContext::makeNativeBuffer(sk_sp<SkImage> image) {
-#if defined(SK_GRAPHITE)
   // A Graphite GPU texture can't be read with readPixels(nullptr) (and can't be
-  // drawn onto a raster surface) — both yield uninitialized/black pixels. Read
-  // it back to a raster image first. (JsiNativeBuffer calls the Ganesh-only
-  // SkImage::makeNonTextureImage(), which is a no-op on Graphite.)
+  // drawn onto a raster surface): both yield uninitialized/black pixels. Read
+  // it back to a raster image first.
   if (image && image->isTextureBacked()) {
     image = DawnContext::getInstance().MakeRasterImage(image);
   }
-#endif
   // 0. If Image is not in BGRA, convert to BGRA as only BGRA is supported.
   if (image->colorType() != kBGRA_8888_SkColorType) {
     const SkImageInfo bgraInfo =
@@ -241,67 +233,6 @@ uint64_t RNSkApplePlatformContext::makeTestNativeBuffer(int width, int height) {
   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) {
-  TextureInfo result;
-  GrBackendTexture texture;
-  if (!SkImages::GetBackendTextureFromImage(image, &texture, true)) {
-    throw std::runtime_error("Couldn't get backend texture");
-  }
-  if (!texture.isValid()) {
-    throw std::runtime_error("Invalid backend texture");
-  }
-  GrMtlTextureInfo textureInfo;
-  if (!GrBackendTextures::GetMtlTextureInfo(texture, &textureInfo)) {
-    throw std::runtime_error("Couldn't get Metal texture info");
-  }
-  result.mtlTexture = textureInfo.fTexture.get();
-  return result;
-}
-
-const TextureInfo
-RNSkApplePlatformContext::getTexture(sk_sp<SkSurface> surface) {
-  TextureInfo result;
-  GrBackendTexture texture = SkSurfaces::GetBackendTexture(
-      surface.get(), SkSurfaces::BackendHandleAccess::kFlushRead);
-  if (!texture.isValid()) {
-    throw std::runtime_error("Invalid backend texture");
-  }
-  GrMtlTextureInfo textureInfo;
-  if (!GrBackendTextures::GetMtlTextureInfo(texture, &textureInfo)) {
-    throw std::runtime_error("Couldn't get Metal texture info");
-  }
-  result.mtlTexture = textureInfo.fTexture.get();
-  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);
@@ -314,54 +245,13 @@ void RNSkApplePlatformContext::raiseError(const std::exception &err) {
 sk_sp<SkSurface>
 RNSkApplePlatformContext::makeOffscreenSurface(int width, int height,
                                                bool useP3ColorSpace) {
-#if defined(SK_GRAPHITE)
   return DawnContext::getInstance().MakeOffscreen(width, height,
                                                   useP3ColorSpace);
-#else
-  return MetalContext::getInstance().MakeOffscreen(width, height,
-                                                   useP3ColorSpace);
-#endif
 }
 
 sk_sp<SkImage>
 RNSkApplePlatformContext::makeImageFromNativeBuffer(void *buffer) {
-#if defined(SK_GRAPHITE)
   return DawnContext::getInstance().MakeImageFromBuffer(buffer);
-#else
-  return MetalContext::getInstance().MakeImageFromBuffer(buffer);
-#endif
-}
-
-SkColorType RNSkApplePlatformContext::mtlPixelFormatToSkColorType(
-    MTLPixelFormat pixelFormat) {
-  switch (pixelFormat) {
-  case MTLPixelFormatRGBA8Unorm:
-    return kRGBA_8888_SkColorType;
-  case MTLPixelFormatBGRA8Unorm:
-    return kBGRA_8888_SkColorType;
-  case MTLPixelFormatRGB10A2Unorm:
-    return kRGBA_1010102_SkColorType;
-  case MTLPixelFormatR8Unorm:
-    return kGray_8_SkColorType;
-  case MTLPixelFormatRGBA16Float:
-    return kRGBA_F16_SkColorType;
-  case MTLPixelFormatRG8Unorm:
-    return kR8G8_unorm_SkColorType;
-  case MTLPixelFormatR16Float:
-    return kA16_float_SkColorType;
-  case MTLPixelFormatRG16Float:
-    return kR16G16_float_SkColorType;
-  case MTLPixelFormatR16Unorm:
-    return kA16_unorm_SkColorType;
-  case MTLPixelFormatRG16Unorm:
-    return kR16G16_unorm_SkColorType;
-  case MTLPixelFormatRGBA16Unorm:
-    return kR16G16B16A16_unorm_SkColorType;
-  case MTLPixelFormatRGBA8Unorm_sRGB:
-    return kSRGBA_8888_SkColorType;
-  default:
-    return kUnknown_SkColorType;
-  }
 }
 
 sk_sp<SkFontMgr> RNSkApplePlatformContext::createFontMgr() {

package/apple/RNSkMetalCanvasProvider.h

@@ -1,43 +1,39 @@
 #pragma once
 
+#import "RNSkCanvasProvider.h"
 #import "RNSkPlatformContext.h"
-#import "RNSkView.h"
 
 #import <MetalKit/MetalKit.h>
 #import <QuartzCore/CAMetalLayer.h>
 
+#include <memory>
 #include <mutex>
 #include <vector>
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#import <include/gpu/ganesh/GrDirectContext.h>
-
-#pragma clang diagnostic pop
-
+/**
+ * The CAMetalLayer a SkiaView presents into. The layer is configured as a
+ * Dawn surface (see DawnWindowContext) when the view gets a size.
+ */
 class RNSkMetalCanvasProvider : public RNSkia::RNSkCanvasProvider {
 public:
-  RNSkMetalCanvasProvider(std::function<void()> requestRedraw,
-                          std::shared_ptr<RNSkia::RNSkPlatformContext> context,
-                          bool useP3ColorSpace = true);
+  explicit RNSkMetalCanvasProvider(
+      std::shared_ptr<RNSkia::RNSkPlatformContext> context);
 
   ~RNSkMetalCanvasProvider();
 
   int getWidth() override;
   int getHeight() override;
 
-  bool renderToCanvas(const std::function<void(SkCanvas *)> &cb) override;
+  bool getTargetInfo(RNSkia::RNSkGraphiteTargetInfo *info) override;
 
-#if defined(SK_GRAPHITE)
-  bool getGraphiteTargetInfo(RNSkia::RNSkGraphiteTargetInfo *info) override;
+  bool getLayoutSize(int *width, int *height) override;
 
   bool presentRecordings(
       const std::vector<skgpu::graphite::Recording *> &recordings) override;
-#endif
+
+  bool presentImage(const sk_sp<SkImage> &image) override;
 
   void setSize(int width, int height);
-  void setUseP3ColorSpace(bool useP3ColorSpace);
   void setHighBitDepth(bool highBitDepth);
   CALayer *getLayer();
 
@@ -48,13 +44,12 @@ private:
 #pragma clang diagnostic ignored "-Wunguarded-availability-new"
   CAMetalLayer *_layer;
 #pragma clang diagnostic pop
-  bool _useP3ColorSpace = true;
   bool _highBitDepth = false;
-#if defined(SK_GRAPHITE)
   // A copy of the window's target description, readable from any thread
   // while the window itself belongs to the main thread.
   std::mutex _targetInfoMutex;
   RNSkia::RNSkGraphiteTargetInfo _targetInfo;
   bool _hasTargetInfo = false;
-#endif
+  int _layoutWidth = 0;
+  int _layoutHeight = 0;
 };

package/apple/RNSkMetalCanvasProvider.mm

@@ -1,31 +1,13 @@
 #import "RNSkMetalCanvasProvider.h"
 
-#import "RNSkLog.h"
-
-#if defined(SK_GRAPHITE)
 #import "RNDawnContext.h"
-#else
-#import "MetalContext.h"
-#endif
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#import "include/core/SkCanvas.h"
-#import "include/core/SkColorSpace.h"
-#import "include/core/SkSurface.h"
-
-#import <include/gpu/ganesh/GrBackendSurface.h>
-#import <include/gpu/ganesh/GrDirectContext.h>
-#import <include/gpu/ganesh/SkSurfaceGanesh.h>
+#import "RNSkLog.h"
 
-#pragma clang diagnostic pop
+#include <cmath>
 
 RNSkMetalCanvasProvider::RNSkMetalCanvasProvider(
-    std::function<void()> requestRedraw,
-    std::shared_ptr<RNSkia::RNSkPlatformContext> context, bool useP3ColorSpace)
-    : RNSkCanvasProvider(requestRedraw), _context(context),
-      _useP3ColorSpace(useP3ColorSpace) {
+    std::shared_ptr<RNSkia::RNSkPlatformContext> context)
+    : _context(std::move(context)) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunguarded-availability-new"
   _layer = [CAMetalLayer layer];
@@ -61,38 +43,7 @@ static bool appIsBackgrounded() {
 #endif // !TARGET_OS_OSX
 }
 
-/**
- Render to a canvas
- */
-bool RNSkMetalCanvasProvider::renderToCanvas(
-    const std::function<void(SkCanvas *)> &cb) {
-  if (!_ctx) {
-    return false;
-  }
-
-  if ([[NSThread currentThread] isMainThread]) {
-    if (appIsBackgrounded()) {
-      // Request a redraw in the next run loop callback
-      _requestRedraw();
-      // and don't draw now since it might cause errors in the metal renderer if
-      // we try to render while in the background. (see above issue)
-      return false;
-    }
-
-    auto surface = _ctx->getSurface();
-    if (!surface) {
-      return false;
-    }
-    auto canvas = surface->getCanvas();
-    cb(canvas);
-    _ctx->present();
-    return true;
-  }
-  return false;
-};
-
-#if defined(SK_GRAPHITE)
-bool RNSkMetalCanvasProvider::getGraphiteTargetInfo(
+bool RNSkMetalCanvasProvider::getTargetInfo(
     RNSkia::RNSkGraphiteTargetInfo *info) {
   std::lock_guard<std::mutex> lock(_targetInfoMutex);
   if (!_hasTargetInfo) {
@@ -102,49 +53,65 @@ bool RNSkMetalCanvasProvider::getGraphiteTargetInfo(
   return true;
 }
 
+bool RNSkMetalCanvasProvider::getLayoutSize(int *width, int *height) {
+  std::lock_guard<std::mutex> lock(_targetInfoMutex);
+  if (_layoutWidth <= 0 || _layoutHeight <= 0) {
+    return false;
+  }
+  *width = _layoutWidth;
+  *height = _layoutHeight;
+  return true;
+}
+
 bool RNSkMetalCanvasProvider::presentRecordings(
     const std::vector<skgpu::graphite::Recording *> &recordings) {
   if (!_ctx || ![[NSThread currentThread] isMainThread]) {
     return false;
   }
   if (appIsBackgrounded()) {
-    _requestRedraw();
+    requestRedraw();
     return false;
   }
   return static_cast<RNSkia::DawnWindowContext *>(_ctx.get())
       ->presentRecordings(recordings);
 }
-#endif
+
+bool RNSkMetalCanvasProvider::presentImage(const sk_sp<SkImage> &image) {
+  if (!_ctx || ![[NSThread currentThread] isMainThread]) {
+    return false;
+  }
+  if (appIsBackgrounded()) {
+    requestRedraw();
+    return false;
+  }
+  return static_cast<RNSkia::DawnWindowContext *>(_ctx.get())
+      ->presentImage(image);
+}
 
 void RNSkMetalCanvasProvider::setSize(int width, int height) {
   _layer.frame = CGRectMake(0, 0, width, height);
-  auto w = width * _context->getPixelDensity();
-  auto h = height * _context->getPixelDensity();
-#if defined(SK_GRAPHITE)
+  // The layout is on the pixel grid: round rather than truncate, so that a
+  // product like 1169.9999 gives the pixel size the layout means.
+  int w = static_cast<int>(std::lround(width * _context->getPixelDensity()));
+  int h = static_cast<int>(std::lround(height * _context->getPixelDensity()));
   _ctx = RNSkia::DawnContext::getInstance().MakeWindow((__bridge void *)_layer,
                                                        w, h, _highBitDepth);
   {
     auto *window = static_cast<RNSkia::DawnWindowContext *>(_ctx.get());
     std::lock_guard<std::mutex> lock(_targetInfoMutex);
+    _layoutWidth = w;
+    _layoutHeight = h;
     _targetInfo.width = window->getWidth();
     _targetInfo.height = window->getHeight();
     _targetInfo.colorType = window->getColorType();
     _targetInfo.textureInfo = window->getTextureInfo();
     _hasTargetInfo = true;
   }
-#else
-  _ctx = MetalContext::getInstance().MakeWindow(_layer, w, h, _useP3ColorSpace,
-                                                _highBitDepth);
-#endif
-  _requestRedraw();
+  requestRedraw();
 }
 
 CALayer *RNSkMetalCanvasProvider::getLayer() { return _layer; }
 
-void RNSkMetalCanvasProvider::setUseP3ColorSpace(bool useP3ColorSpace) {
-  _useP3ColorSpace = useP3ColorSpace;
-}
-
 void RNSkMetalCanvasProvider::setHighBitDepth(bool highBitDepth) {
   if (_highBitDepth == highBitDepth) {
     return;