react-native-skia 3.0.1 → 3.0.3

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>
@@ -10,20 +8,22 @@
 
 namespace RNSkia {
 
-// WebGPU canvas values are sRGB-encoded regardless of the texture format
-// (GPUCanvasConfiguration.colorSpace defaults to "srgb"), so the same shader
-// output must display identically on bgra8unorm and rgba16float surfaces.
-// Tagging the float layer as (gamma-encoded) extended sRGB matches the
-// browser behavior: identical colors, with the extra precision of float16.
+// The surface holds gamma-encoded values in the gamut the view renders in
+// (sRGB or Display P3, see DawnUtils::viewColorSpace) regardless of the
+// texture format, so the same content must display identically on bgra8unorm
+// and rgba16float surfaces. Tagging the float layer with the gamma-encoded
+// extended colorspace of that gamut gives identical colors, with the extra
+// precision of float16.
 void applyCAMetalLayerColorSpace(void *nativeSurface,
-                                 wgpu::TextureFormat format) {
+                                 wgpu::TextureFormat format,
+                                 bool useP3ColorSpace) {
   CALayer *layer = (__bridge CALayer *)nativeSurface;
   if (![layer isKindOfClass:[CAMetalLayer class]]) {
     return;
   }
   auto metalLayer = static_cast<CAMetalLayer *>(layer);
-  setCAMetalLayerColorSpace(metalLayer,
-                            format == wgpu::TextureFormat::RGBA16Float, false);
+  setCAMetalLayerColorSpace(
+      metalLayer, format == wgpu::TextureFormat::RGBA16Float, useP3ColorSpace);
   // The change must be set synchronously so the first present already sees
   // it, and it must reach the render server. On a non-main thread (RN JS or
   // worklet runtime) the property lands in that thread's implicit
@@ -35,5 +35,3 @@ void applyCAMetalLayerColorSpace(void *nativeSurface,
 }
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE

package/apple/RNSkApplePlatformContext.h

@@ -32,28 +32,27 @@ public:
     // Create screenshot manager
     _screenshotService =
         [[ViewScreenshotService alloc] initWithViewRegistry:viewRegistry];
+    _prefersP3ColorSpace = mainScreenSupportsP3();
   }
 
   ~RNSkApplePlatformContext() = default;
 
+  /**
+   Whether the main screen has a wide color gamut (Display P3). The screen is
+   asked once and the answer is kept: RNSkiaModule asks first, on the main
+   queue it is created on, so that the context (created on the JS thread)
+   only reads the answer.
+   */
+  static bool mainScreenSupportsP3();
+
+  bool prefersP3ColorSpace() override { return _prefersP3ColorSpace; }
+
   void runOnMainThread(std::function<void()>) override;
 
   sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) override;
 
   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 +77,7 @@ public:
 
 private:
   ViewScreenshotService *_screenshotService;
-
-  SkColorType mtlPixelFormatToSkColorType(MTLPixelFormat pixelFormat);
+  bool _prefersP3ColorSpace = false;
 };
 
 } // 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);
@@ -311,57 +242,33 @@ void RNSkApplePlatformContext::raiseError(const std::exception &err) {
   RCTFatal(RCTErrorWithMessage([NSString stringWithUTF8String:err.what()]));
 }
 
+bool RNSkApplePlatformContext::mainScreenSupportsP3() {
+  static bool supportsP3 = false;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+#if !TARGET_OS_OSX
+    supportsP3 =
+        [UIScreen mainScreen].traitCollection.displayGamut == UIDisplayGamutP3;
+#else
+    NSColorSpace *screenColorSpace = [NSScreen mainScreen].colorSpace;
+    supportsP3 =
+        screenColorSpace != nil &&
+        [screenColorSpace isEqual:[NSColorSpace displayP3ColorSpace]];
+#endif // !TARGET_OS_OSX
+  });
+  return supportsP3;
+}
+
 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;
 };