@shopify/react-native-skia 1.12.0 → 1.12.2

package/apple/SkiaCVPixelBufferUtils.mm

@@ -0,0 +1,344 @@
+//
+//  SkiaCVPixelBufferUtils.mm
+//  react-native-skia
+//
+//  Created by Marc Rousavy on 10.04.24.
+//
+
+#import "SkiaCVPixelBufferUtils.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import "include/core/SkCanvas.h"
+#import "include/core/SkColorSpace.h"
+
+#import <CoreMedia/CMSampleBuffer.h>
+#import <CoreVideo/CVMetalTextureCache.h>
+
+#import <include/gpu/ganesh/GrBackendSurface.h>
+#import <include/gpu/ganesh/GrDirectContext.h>
+#import <include/gpu/ganesh/SkImageGanesh.h>
+#import <include/gpu/ganesh/SkSurfaceGanesh.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendContext.h>
+#import <include/gpu/ganesh/mtl/GrMtlBackendSurface.h>
+#import <include/gpu/ganesh/mtl/GrMtlDirectContext.h>
+#import <include/gpu/ganesh/mtl/SkSurfaceMetal.h>
+
+#pragma clang diagnostic pop
+
+#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                                            \
+  }
+#else
+#define FourCC2Str(fourcc)                                                     \
+  (const char[]) {                                                             \
+    *(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),                        \
+        *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0                  \
+  }
+#endif
+
+// pragma MARK: TextureHolder
+
+TextureHolder::TextureHolder(CVMetalTextureRef texture) : _texture(texture) {}
+TextureHolder::~TextureHolder() {
+  // ARC will now automatically release _texture.
+  CFRelease(_texture);
+}
+
+GrBackendTexture TextureHolder::toGrBackendTexture() {
+  // Unwrap the underlying MTLTexture
+  id<MTLTexture> mtlTexture = CVMetalTextureGetTexture(_texture);
+  if (mtlTexture == nil) [[unlikely]] {
+    throw std::runtime_error(
+        "Failed to get MTLTexture from CVMetalTextureRef!");
+  }
+
+  // Wrap MTLTexture in Skia's GrBackendTexture
+  GrMtlTextureInfo textureInfo;
+  textureInfo.fTexture.retain((__bridge void *)mtlTexture);
+  GrBackendTexture texture =
+      GrBackendTextures::MakeMtl((int)mtlTexture.width, (int)mtlTexture.height,
+                                 skgpu::Mipmapped::kNo, textureInfo);
+  return texture;
+}
+
+MultiTexturesHolder::~MultiTexturesHolder() {
+  for (TextureHolder *texture : _textures) {
+    delete texture;
+  }
+}
+
+void MultiTexturesHolder::addTexture(TextureHolder *texture) {
+  _textures.push_back(texture);
+}
+
+// pragma MARK: Base
+
+SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat
+SkiaCVPixelBufferUtils::getCVPixelBufferBaseFormat(
+    CVPixelBufferRef pixelBuffer) {
+  OSType format = CVPixelBufferGetPixelFormatType(pixelBuffer);
+
+  switch (format) {
+  // 8-bit YUV formats
+  case kCVPixelFormatType_420YpCbCr8Planar:
+  case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+  // 10-bit YUV formats
+  case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarFullRange:
+    return CVPixelBufferBaseFormat::yuv;
+  case kCVPixelFormatType_24RGB:
+  case kCVPixelFormatType_24BGR:
+  case kCVPixelFormatType_32ARGB:
+  case kCVPixelFormatType_32BGRA:
+  case kCVPixelFormatType_32ABGR:
+  case kCVPixelFormatType_32RGBA:
+    return CVPixelBufferBaseFormat::rgb;
+  default:
+    [[unlikely]] throw std::runtime_error(
+        "CVPixelBuffer has unknown pixel format! " +
+        std::string("Expected: any RGB or YUV format, Received: ") +
+        std::string(FourCC2Str(format)));
+  }
+}
+
+// pragma MARK: RGB
+
+SkColorType SkiaCVPixelBufferUtils::RGB::getCVPixelBufferColorType(
+    CVPixelBufferRef pixelBuffer) {
+  OSType format = CVPixelBufferGetPixelFormatType(pixelBuffer);
+
+  switch (format) {
+  case kCVPixelFormatType_32BGRA:
+    [[likely]] return kBGRA_8888_SkColorType;
+  case kCVPixelFormatType_32RGBA:
+    return kRGBA_8888_SkColorType;
+  // This can be extended with branches for specific RGB formats if Apple
+  // uses new formats.
+  default:
+    [[unlikely]] throw std::runtime_error(
+        "CVPixelBuffer has unknown RGB format! " +
+        std::string(FourCC2Str(format)));
+  }
+}
+
+sk_sp<SkImage> SkiaCVPixelBufferUtils::RGB::makeSkImageFromCVPixelBuffer(
+    GrDirectContext *context, CVPixelBufferRef pixelBuffer) {
+  // 1. Get Skia color type for RGB buffer
+  SkColorType colorType = getCVPixelBufferColorType(pixelBuffer);
+
+  // 2. Get texture, RGB buffers only have one plane
+  TextureHolder *texture =
+      getSkiaTextureForCVPixelBufferPlane(pixelBuffer, /* planeIndex */ 0);
+
+  // 3. Convert to image with manual memory cleanup
+  return SkImages::BorrowTextureFrom(
+      context, texture->toGrBackendTexture(), kTopLeft_GrSurfaceOrigin,
+      colorType, kOpaque_SkAlphaType, nullptr,
+      [](void *texture) { delete (TextureHolder *)texture; }, (void *)texture);
+}
+
+// pragma MARK: YUV
+
+sk_sp<SkImage> SkiaCVPixelBufferUtils::YUV::makeSkImageFromCVPixelBuffer(
+    GrDirectContext *context, CVPixelBufferRef pixelBuffer) {
+  // 1. Get all planes (YUV, Y_UV, Y_U_V or Y_U_V_A)
+  size_t planesCount = CVPixelBufferGetPlaneCount(pixelBuffer);
+  MultiTexturesHolder *texturesHolder = new MultiTexturesHolder();
+  GrBackendTexture textures[planesCount];
+
+  for (size_t planeIndex = 0; planeIndex < planesCount; planeIndex++) {
+    TextureHolder *textureHolder =
+        getSkiaTextureForCVPixelBufferPlane(pixelBuffer, planeIndex);
+    textures[planeIndex] = textureHolder->toGrBackendTexture();
+    texturesHolder->addTexture(textureHolder);
+  }
+
+  // 2. Wrap info about buffer
+  SkYUVAInfo info = getYUVAInfoForCVPixelBuffer(pixelBuffer);
+
+  // 3. Wrap as YUVA textures type
+  GrYUVABackendTextures yuvaTextures(info, textures, kTopLeft_GrSurfaceOrigin);
+
+  // 4. Wrap into SkImage type with manualy memory cleanup
+  return SkImages::TextureFromYUVATextures(
+      context, yuvaTextures, nullptr,
+      [](void *textureHolders) {
+        delete (MultiTexturesHolder *)textureHolders;
+      },
+      (void *)texturesHolder);
+}
+
+SkYUVAInfo SkiaCVPixelBufferUtils::YUV::getYUVAInfoForCVPixelBuffer(
+    CVPixelBufferRef pixelBuffer) {
+  size_t width = CVPixelBufferGetWidth(pixelBuffer);
+  size_t height = CVPixelBufferGetHeight(pixelBuffer);
+  SkISize size =
+      SkISize::Make(static_cast<int>(width), static_cast<int>(height));
+
+  OSType format = CVPixelBufferGetPixelFormatType(pixelBuffer);
+  SkYUVAInfo::PlaneConfig planeConfig = getPlaneConfig(format);
+  SkYUVAInfo::Subsampling subsampling = getSubsampling(format);
+  SkYUVColorSpace colorspace = getColorspace(format);
+
+  return SkYUVAInfo(size, planeConfig, subsampling, colorspace);
+}
+
+// pragma MARK: YUV getPlaneConfig()
+
+SkYUVAInfo::PlaneConfig
+SkiaCVPixelBufferUtils::YUV::getPlaneConfig(OSType pixelFormat) {
+  switch (pixelFormat) {
+  case kCVPixelFormatType_420YpCbCr8Planar:
+  case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
+    return SkYUVAInfo::PlaneConfig::kYUV;
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarFullRange:
+    [[likely]] return SkYUVAInfo::PlaneConfig::kY_UV;
+
+  // This can be extended with branches for specific YUV formats if Apple
+  // uses new formats.
+  default:
+    [[unlikely]] throw std::runtime_error("Invalid pixel format! " +
+                                          std::string(FourCC2Str(pixelFormat)));
+  }
+}
+
+// pragma MARK: YUV getSubsampling()
+
+SkYUVAInfo::Subsampling
+SkiaCVPixelBufferUtils::YUV::getSubsampling(OSType pixelFormat) {
+  switch (pixelFormat) {
+  case kCVPixelFormatType_420YpCbCr8Planar:
+  case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange:
+    [[likely]] return SkYUVAInfo::Subsampling::k420;
+  case kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarFullRange:
+    return SkYUVAInfo::Subsampling::k422;
+  case kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarFullRange:
+    return SkYUVAInfo::Subsampling::k444;
+  // This can be extended with branches for specific YUV formats if Apple
+  // uses new formats.
+  default:
+    [[unlikely]] throw std::runtime_error("Invalid pixel format! " +
+                                          std::string(FourCC2Str(pixelFormat)));
+  }
+}
+
+// pragma MARK: YUV getColorspace()
+
+SkYUVColorSpace SkiaCVPixelBufferUtils::YUV::getColorspace(OSType pixelFormat) {
+  switch (pixelFormat) {
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+    [[likely]]
+    // 8-bit limited
+    return SkYUVColorSpace::kRec709_Limited_SkYUVColorSpace;
+  case kCVPixelFormatType_420YpCbCr8Planar:
+  case kCVPixelFormatType_420YpCbCr8PlanarFullRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+    [[likely]]
+    // 8-bit full
+    return SkYUVColorSpace::kRec709_Full_SkYUVColorSpace;
+  case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange:
+    // 10-bit limited
+    return SkYUVColorSpace::kBT2020_10bit_Limited_SkYUVColorSpace;
+  case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_422YpCbCr10BiPlanarFullRange:
+  case kCVPixelFormatType_444YpCbCr10BiPlanarFullRange:
+    // 10-bit full
+    return SkYUVColorSpace::kBT2020_10bit_Full_SkYUVColorSpace;
+  // This can be extended with branches for specific YUV formats if Apple
+  // uses new formats.
+  default:
+    [[unlikely]] throw std::runtime_error("Invalid pixel format! " +
+                                          std::string(FourCC2Str(pixelFormat)));
+  }
+}
+
+// pragma MARK: CVPixelBuffer -> Skia Texture
+
+TextureHolder *SkiaCVPixelBufferUtils::getSkiaTextureForCVPixelBufferPlane(
+    CVPixelBufferRef pixelBuffer, size_t planeIndex) {
+  // 1. Get cache
+  CVMetalTextureCacheRef textureCache = getTextureCache();
+
+  // 2. Get MetalTexture from CMSampleBuffer
+  size_t width = CVPixelBufferGetWidthOfPlane(pixelBuffer, planeIndex);
+  size_t height = CVPixelBufferGetHeightOfPlane(pixelBuffer, planeIndex);
+  MTLPixelFormat pixelFormat =
+      getMTLPixelFormatForCVPixelBufferPlane(pixelBuffer, planeIndex);
+
+  CVMetalTextureRef textureHolder;
+  CVReturn result = CVMetalTextureCacheCreateTextureFromImage(
+      kCFAllocatorDefault, textureCache, pixelBuffer, nil, pixelFormat, width,
+      height, planeIndex, &textureHolder);
+
+  if (result != kCVReturnSuccess) [[unlikely]] {
+    throw std::runtime_error(
+        "Failed to create Metal Texture from CMSampleBuffer! Result: " +
+        std::to_string(result));
+  }
+
+  return new TextureHolder(textureHolder);
+}
+
+// pragma MARK: getTextureCache()
+
+CVMetalTextureCacheRef SkiaCVPixelBufferUtils::getTextureCache() {
+  static CVMetalTextureCacheRef textureCache = nil;
+  if (textureCache == nil) {
+    // Create a new Texture Cache
+    auto result = CVMetalTextureCacheCreate(kCFAllocatorDefault, nil,
+                                            MTLCreateSystemDefaultDevice(), nil,
+                                            &textureCache);
+    if (result != kCVReturnSuccess || textureCache == nil) {
+      throw std::runtime_error("Failed to create Metal Texture Cache!");
+    }
+  }
+  return textureCache;
+}
+
+// pragma MARK: Get CVPixelBuffer MTLPixelFormat
+
+MTLPixelFormat SkiaCVPixelBufferUtils::getMTLPixelFormatForCVPixelBufferPlane(
+    CVPixelBufferRef pixelBuffer, size_t planeIndex) {
+  size_t width = CVPixelBufferGetWidthOfPlane(pixelBuffer, planeIndex);
+  size_t bytesPerRow =
+      CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, planeIndex);
+  double bytesPerPixel = round(static_cast<double>(bytesPerRow) / width);
+  if (bytesPerPixel == 1) {
+    return MTLPixelFormatR8Unorm;
+  } else if (bytesPerPixel == 2) {
+    return MTLPixelFormatRG8Unorm;
+  } else if (bytesPerPixel == 4) {
+    return MTLPixelFormatBGRA8Unorm;
+  } else [[unlikely]] {
+    throw std::runtime_error("Invalid bytes per row! Expected 1 (R), 2 (RG) or "
+                             "4 (RGBA), but received " +
+                             std::to_string(bytesPerPixel));
+  }
+}

package/apple/SkiaManager.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#import <React/RCTBridge.h>
+
+#import "RNSkManager.h"
+
+@interface SkiaManager : NSObject
+
+- (std::shared_ptr<RNSkia::RNSkManager>)skManager;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+- (void)invalidate;
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                     jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)
+                                   jsInvoker;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+// Fabric components do not have a better way to interact with TurboModules.
+// Workaround to get the SkManager instance from singleton.
++ (std::shared_ptr<RNSkia::RNSkManager>)latestActiveSkManager;
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end

package/apple/SkiaManager.mm

@@ -0,0 +1,62 @@
+#import "SkiaManager.h"
+
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+
+#import "RNSkApplePlatformContext.h"
+
+static __weak SkiaManager *sharedInstance = nil;
+
+@implementation SkiaManager {
+  std::shared_ptr<RNSkia::RNSkManager> _skManager;
+  __weak RCTBridge *weakBridge;
+}
+
+- (std::shared_ptr<RNSkia::RNSkManager>)skManager {
+  return _skManager;
+}
+
+- (void)invalidate {
+  if (_skManager != nullptr) {
+    _skManager->invalidate();
+  }
+  _skManager = nullptr;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+                     jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)
+                                   jsInvoker {
+  self = [super init];
+  if (self) {
+    sharedInstance = self;
+    RCTCxxBridge *cxxBridge = (RCTCxxBridge *)bridge;
+    if (cxxBridge.runtime) {
+
+      facebook::jsi::Runtime *jsRuntime =
+          (facebook::jsi::Runtime *)cxxBridge.runtime;
+
+      // Create the RNSkiaManager (cross platform)
+      _skManager = std::make_shared<RNSkia::RNSkManager>(
+          jsRuntime, jsInvoker,
+          std::make_shared<RNSkia::RNSkApplePlatformContext>(bridge, jsInvoker));
+    }
+  }
+  return self;
+}
+
+- (void)dealloc {
+  sharedInstance = nil;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
++ (std::shared_ptr<RNSkia::RNSkManager>)latestActiveSkManager {
+  if (sharedInstance != nil) {
+    return [sharedInstance skManager];
+  }
+  return nullptr;
+}
+#endif // RCT_NEW_ARCH_ENABLED
+@end

package/apple/SkiaPictureView.h

@@ -0,0 +1,7 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "SkiaUIView.h"
+
+@interface SkiaPictureView : SkiaUIView
+
+@end
+#endif // RCT_NEW_ARCH_ENABLED

package/apple/SkiaPictureView.mm

@@ -0,0 +1,66 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "SkiaPictureView.h"
+
+#import "RNSkAppleView.h"
+#import "RNSkPictureView.h"
+#import "RNSkPlatformContext.h"
+
+#import "RNSkiaModule.h"
+#import "SkiaManager.h"
+#import "SkiaUIView.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/rnskia/ComponentDescriptors.h>
+#import <react/renderer/components/rnskia/EventEmitters.h>
+#import <react/renderer/components/rnskia/Props.h>
+#import <react/renderer/components/rnskia/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+@implementation SkiaPictureView
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    // Pass SkManager as a raw pointer to avoid circular dependencies
+    auto skManager = [SkiaManager latestActiveSkManager].get();
+    [self initCommon:skManager
+             factory:[](std::shared_ptr<RNSkia::RNSkPlatformContext> context) {
+               return std::make_shared<RNSkAppleView<RNSkia::RNSkPictureView>>(
+                   context);
+             }];
+    static const auto defaultProps =
+        std::make_shared<const SkiaPictureViewProps>();
+    _props = defaultProps;
+  }
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      SkiaPictureViewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps {
+  const auto &newProps =
+      *std::static_pointer_cast<const SkiaPictureViewProps>(props);
+  [super updateProps:props oldProps:oldProps];
+  int nativeId =
+      [[RCTConvert NSString:RCTNSStringFromString(newProps.nativeId)] intValue];
+  [self setNativeId:nativeId];
+  [self setDebugMode:newProps.debug];
+  [self setOpaque:newProps.opaque];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> SkiaPictureViewCls(void) {
+  return SkiaPictureView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/apple/SkiaPictureViewManager.h

@@ -0,0 +1,8 @@
+
+#pragma once
+
+#import <React/RCTViewManager.h>
+
+@interface SkiaPictureViewManager : RCTViewManager
+
+@end

package/apple/SkiaPictureViewManager.mm

@@ -0,0 +1,55 @@
+
+#include "SkiaPictureViewManager.h"
+#include <React/RCTBridge+Private.h>
+
+#include "RNSkAppleView.h"
+#include "RNSkPictureView.h"
+#include "RNSkPlatformContext.h"
+
+#include "RNSkiaModule.h"
+#include "SkiaManager.h"
+#include "SkiaUIView.h"
+
+@implementation SkiaPictureViewManager
+
+RCT_EXPORT_MODULE(SkiaPictureView)
+
+- (SkiaManager *)skiaManager {
+  auto bridge = self.bridge;
+  RCTAssert(bridge, @"Bridge must not be nil.");
+  auto skiaModule = (RNSkiaModule *)[bridge moduleForName:@"RNSkiaModule"];
+  return [skiaModule manager];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(nativeID, NSNumber, SkiaUIView) {
+  // Get parameter
+  int nativeId = [[RCTConvert NSString:json] intValue];
+  [(SkiaUIView *)view setNativeId:nativeId];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(debug, BOOL, SkiaUIView) {
+  bool debug = json != NULL ? [RCTConvert BOOL:json] : false;
+  [(SkiaUIView *)view setDebugMode:debug];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(opaque, BOOL, SkiaUIView) {
+  bool opaque = json != NULL ? [RCTConvert BOOL:json] : false;
+  [(SkiaUIView *)view setOpaque:opaque];
+}
+
+#if !TARGET_OS_OSX
+- (UIView *)view {
+#else
+- (RCTUIView *)view {
+#endif // !TARGET_OS_OSX
+  auto skManager = [[self skiaManager] skManager];
+  // Pass SkManager as a raw pointer to avoid circular dependenciesr
+  return [[SkiaUIView alloc]
+      initWithManager:skManager.get()
+              factory:[](std::shared_ptr<RNSkia::RNSkPlatformContext> context) {
+                return std::make_shared<RNSkAppleView<RNSkia::RNSkPictureView>>(
+                    context);
+              }];
+}
+
+@end

package/apple/SkiaUIView.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#import <memory>
+#import <string>
+
+#import <CoreFoundation/CoreFoundation.h>
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#else
+#import <React/RCTUIKit.h>
+#endif // !TARGET_OS_OSX
+
+#import "RNSkManager.h"
+#import "RNSkAppleView.h"
+#import "SkiaManager.h"
+
+#if RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+@interface SkiaUIView :
+#if RCT_NEW_ARCH_ENABLED
+    RCTViewComponentView
+#else
+#if !TARGET_OS_OSX
+    UIView
+#else
+    RCTUIView
+#endif // !TARGET_OS_OSX
+#endif // RCT_NEW_ARCH_ENABLED
+
+- (instancetype)
+    initWithManager:(RNSkia::RNSkManager *)manager
+            factory:(std::function<std::shared_ptr<RNSkBaseAppleView>(
+                         std::shared_ptr<RNSkia::RNSkPlatformContext>)>)factory;
+- (void)initCommon:(RNSkia::RNSkManager *)manager
+           factory:(std::function<std::shared_ptr<RNSkBaseAppleView>(
+                        std::shared_ptr<RNSkia::RNSkPlatformContext>)>)factory;
+- (std::shared_ptr<RNSkBaseAppleView>)impl;
+
+- (void)setDebugMode:(bool)debugMode;
+- (void)setOpaque:(bool)opaque;
+- (void)setNativeId:(size_t)nativeId;
+
+@end