@shopify/react-native-skia 1.6.0 → 1.7.1

package/cpp/api/third_party/CSSColorParser.h

@@ -34,7 +34,7 @@
 namespace CSSColorParser {
 
 struct Color {
-  inline Color() {}
+  inline Color() = default;
   inline Color(unsigned char r_, unsigned char g_, unsigned char b_, float a_)
       : r(r_), g(g_), b(b_), a(a_ > 1   ? 1
                                : a_ < 0 ? 0

package/cpp/api/third_party/base64.cpp

@@ -26,8 +26,8 @@ namespace RNSkia {
 
 Base64::Error Base64::Decode(const void *srcv, size_t srcLength, void *dstv,
                              size_t *dstLength) {
-  const unsigned char *src = static_cast<const unsigned char *>(srcv);
-  unsigned char *dst = static_cast<unsigned char *>(dstv);
+  auto *src = static_cast<const unsigned char *>(srcv);
+  auto *dst = static_cast<unsigned char *>(dstv);
 
   int i = 0;
   bool padTwo = false;
@@ -112,8 +112,8 @@ Base64::Error Base64::Decode(const void *srcv, size_t srcLength, void *dstv,
 }
 
 size_t Base64::Encode(const void *srcv, size_t length, void *dstv) {
-  const unsigned char *src = static_cast<const unsigned char *>(srcv);
-  unsigned char *dst = static_cast<unsigned char *>(dstv);
+  auto *src = static_cast<const unsigned char *>(srcv);
+  auto *dst = static_cast<unsigned char *>(dstv);
 
   const char *encode = kDefaultEncode;
   if (dst) {

package/cpp/jsi/ViewProperty.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+
+#include "JsiDomRenderNode.h"
+#include "JsiSkPicture.h"
+
+namespace RNJsi {
+namespace jsi = facebook::jsi;
+
+class ViewProperty {
+public:
+  ViewProperty(jsi::Runtime &runtime, const jsi::Value &value) {
+    if (value.isObject()) {
+      auto object = value.asObject(runtime);
+      if (object.isHostObject(runtime)) {
+        auto hostObject = object.asHostObject(runtime);
+        auto dom =
+            std::dynamic_pointer_cast<RNSkia::JsiDomRenderNode>(hostObject);
+        if (dom) {
+          _value = dom;
+        } else {
+          auto jsiPicture =
+              std::dynamic_pointer_cast<RNSkia::JsiSkPicture>(hostObject);
+          if (jsiPicture) {
+            _value = jsiPicture->getObject();
+          }
+        }
+      }
+    }
+  }
+
+  bool isNull() { return std::holds_alternative<nullptr_t>(_value); }
+
+  std::shared_ptr<RNSkia::JsiDomRenderNode> getDomRenderNode() {
+    return std::get<std::shared_ptr<RNSkia::JsiDomRenderNode>>(_value);
+  }
+
+  sk_sp<SkPicture> getPicture() { return std::get<sk_sp<SkPicture>>(_value); }
+
+private:
+  std::variant<nullptr_t, sk_sp<SkPicture>,
+               std::shared_ptr<RNSkia::JsiDomRenderNode>>
+      _value = nullptr;
+};
+} // namespace RNJsi

package/cpp/rnskia/RNSkDomView.h

@@ -9,8 +9,8 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiValueWrapper.h"
 #include "RNSkView.h"
+#include "ViewProperty.h"
 
 #include "JsiDomRenderNode.h"
 #include "RNSkLog.h"
@@ -75,20 +75,17 @@ public:
                      std::bind(&RNSkView::requestRedraw, this), context)) {}
 
   void setJsiProperties(
-      std::unordered_map<std::string, JsiValueWrapper> &props) override {
-
-    RNSkView::setJsiProperties(props);
+      std::unordered_map<std::string, ViewProperty> &props) override {
 
     for (auto &prop : props) {
       if (prop.first == "root") {
         // Save root
-        if (prop.second.isUndefined() || prop.second.isNull()) {
+        if (prop.second.isNull()) {
           std::static_pointer_cast<RNSkDomRenderer>(getRenderer())
               ->setRoot(nullptr);
         } else {
           std::static_pointer_cast<RNSkDomRenderer>(getRenderer())
-              ->setRoot(std::dynamic_pointer_cast<JsiDomRenderNode>(
-                  prop.second.getAsHostObject()));
+              ->setRoot(prop.second.getDomRenderNode());
         }
 
         // Request redraw

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -9,9 +9,9 @@
 #include <vector>
 
 #include "JsiHostObject.h"
-#include "JsiValueWrapper.h"
 #include "RNSkPlatformContext.h"
 #include "RNSkView.h"
+#include "ViewProperty.h"
 #include <jsi/jsi.h>
 
 namespace RNSkia {
@@ -20,7 +20,7 @@ namespace jsi = facebook::jsi;
 using RNSkViewInfo = struct RNSkViewInfo {
   RNSkViewInfo() { view = nullptr; }
   std::shared_ptr<RNSkView> view;
-  std::unordered_map<std::string, RNJsi::JsiValueWrapper> props;
+  std::unordered_map<std::string, RNJsi::ViewProperty> props;
 };
 
 class RNSkJsiViewApi : public RNJsi::JsiHostObject,
@@ -57,7 +57,7 @@ public:
     auto info = getEnsuredViewInfo(nativeId);
 
     info->props.insert_or_assign(arguments[1].asString(runtime).utf8(runtime),
-                                 RNJsi::JsiValueWrapper(runtime, arguments[2]));
+                                 RNJsi::ViewProperty(runtime, arguments[2]));
 
     // Now let's see if we have a view that we can update
     if (info->view != nullptr) {

package/cpp/rnskia/RNSkManager.cpp

@@ -69,7 +69,7 @@ void RNSkManager::installBindings() {
   // Create the API objects and install it on the global object in the
   // provided runtime.
 
-  auto skiaApi = std::make_shared<JsiSkApi>(*_jsRuntime, _platformContext);
+  auto skiaApi = std::make_shared<JsiSkApi>(_platformContext);
   _jsRuntime->global().setProperty(
       *_jsRuntime, "SkiaApi",
       jsi::Object::createFromHostObject(*_jsRuntime, std::move(skiaApi)));

package/cpp/rnskia/RNSkPictureView.h

@@ -9,8 +9,8 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiValueWrapper.h"
 #include "RNSkView.h"
+#include "ViewProperty.h"
 
 #include "JsiSkPicture.h"
 #include "RNSkLog.h"
@@ -40,19 +40,16 @@ class RNSkPictureRenderer
 public:
   RNSkPictureRenderer(std::function<void()> requestRedraw,
                       std::shared_ptr<RNSkPlatformContext> context)
-      : RNSkRenderer(std::move(requestRedraw)), _platformContext(std::move(context)) {}
+      : RNSkRenderer(std::move(requestRedraw)),
+        _platformContext(std::move(context)) {}
 
   void
   renderImmediate(std::shared_ptr<RNSkCanvasProvider> canvasProvider) override {
     performDraw(canvasProvider);
   }
 
-  void setPicture(std::shared_ptr<jsi::HostObject> picture) {
-    if (picture == nullptr) {
-      _picture = nullptr;
-    } else {
-      _picture = std::dynamic_pointer_cast<JsiSkPicture>(picture)->getObject();
-    }
+  void setPicture(sk_sp<SkPicture> picture) {
+    _picture = picture;
     _requestRedraw();
   }
 
@@ -88,27 +85,20 @@ public:
                 std::bind(&RNSkPictureView::requestRedraw, this), context)) {}
 
   void setJsiProperties(
-      std::unordered_map<std::string, RNJsi::JsiValueWrapper> &props) override {
-
-    RNSkView::setJsiProperties(props);
+      std::unordered_map<std::string, RNJsi::ViewProperty> &props) override {
 
     for (auto &prop : props) {
       if (prop.first == "picture") {
-        if (prop.second.isUndefinedOrNull()) {
+        if (prop.second.isNull()) {
           // Clear picture
           std::static_pointer_cast<RNSkPictureRenderer>(getRenderer())
               ->setPicture(nullptr);
           continue;
-        } else if (prop.second.getType() !=
-                   RNJsi::JsiWrapperValueType::HostObject) {
-          // We expect a function for the picture custom property
-          throw std::runtime_error(
-              "Expected an object for the picture custom property.");
         }
 
         // Save picture
         std::static_pointer_cast<RNSkPictureRenderer>(getRenderer())
-            ->setPicture(prop.second.getAsHostObject());
+            ->setPicture(prop.second.getPicture());
       }
     }
   }

package/cpp/rnskia/RNSkPlatformContext.h

@@ -23,25 +23,28 @@
 
 #pragma clang diagnostic pop
 
-#include <jsi/jsi.h>
-
 #include <ReactCommon/CallInvoker.h>
 
 namespace RNSkia {
 
-namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
+struct TextureInfo {
+  const void *mtlTexture = nullptr;
+  unsigned int glTarget = 0;
+  unsigned int glID = 0;
+  unsigned int glFormat = 0;
+  bool glProtected = false;
+};
+
 class RNSkPlatformContext {
 public:
   /**
    * Constructor
    */
-  RNSkPlatformContext(jsi::Runtime *runtime,
-                      std::shared_ptr<react::CallInvoker> callInvoker,
+  RNSkPlatformContext(std::shared_ptr<react::CallInvoker> callInvoker,
                       float pixelDensity)
-      : _pixelDensity(pixelDensity), _jsRuntime(runtime),
-        _callInvoker(callInvoker) {}
+      : _pixelDensity(pixelDensity), _callInvoker(callInvoker) {}
 
   virtual ~RNSkPlatformContext() = default;
 
@@ -65,11 +68,6 @@ public:
    */
   virtual sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) = 0;
 
-  /**
-   Returns the javascript runtime
-   */
-  jsi::Runtime *getJsRuntime() { return _jsRuntime; }
-
   /**
    * Returns an SkStream wrapping the require uri provided.
    * @param sourceUri Uri for the resource to load as a string
@@ -107,6 +105,10 @@ public:
    */
   virtual sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) = 0;
 
+  virtual sk_sp<SkImage>
+  makeImageFromNativeTexture(const TextureInfo &textureInfo, int width,
+                             int height, bool mipMapped) = 0;
+
 #if !defined(SK_GRAPHITE)
   virtual GrDirectContext *getDirectContext() = 0;
 #endif
@@ -115,6 +117,10 @@ public:
 
   virtual uint64_t makeNativeBuffer(sk_sp<SkImage> image) = 0;
 
+  virtual const TextureInfo getTexture(sk_sp<SkSurface> image) = 0;
+
+  virtual const TextureInfo getTexture(sk_sp<SkImage> image) = 0;
+
   virtual std::shared_ptr<RNSkVideo> createVideo(const std::string &url) = 0;
 
   /**
@@ -154,7 +160,6 @@ public:
 
 private:
   float _pixelDensity;
-  jsi::Runtime *_jsRuntime;
   std::shared_ptr<react::CallInvoker> _callInvoker;
 };
 } // namespace RNSkia

package/cpp/rnskia/RNSkView.h

@@ -6,8 +6,8 @@
 #include <unordered_map>
 #include <vector>
 
-#include "JsiValueWrapper.h"
 #include "RNSkPlatformContext.h"
+#include "ViewProperty.h"
 
 #include "JsiSkImage.h"
 #include "JsiSkPoint.h"
@@ -143,14 +143,8 @@ public:
    */
   virtual ~RNSkView() {}
 
-  /**
-   Sets custom properties. Custom properties are properties that are set
-   directly from Javascript without having to go through the async bridge.
-   */
   virtual void setJsiProperties(
-      std::unordered_map<std::string, RNJsi::JsiValueWrapper> &props) {
-    // Nothing here...
-  }
+      std::unordered_map<std::string, RNJsi::ViewProperty> &props) = 0;
 
   void requestRedraw() {
     if (!_redrawRequested) {

package/ios/RNSkia-iOS/MetalContext.h

@@ -1,13 +1,64 @@
 #pragma once
 
-#include "SkiaMetalSurfaceFactory.h"
-#include "WindowContext.h"
+#include "MetalWindowContext.h"
+#include "SkiaCVPixelBufferUtils.h"
 
 #include "include/core/SkSurface.h"
 
-namespace RNSkia {
-class RNSkiOSPlatformContext;
-}
+#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>
+
+// namespace RNSkia {
+// class RNSkiOSPlatformContext;
+// }
+
+class MetalSharedContext {
+public:
+  static MetalSharedContext &getInstance() {
+    static MetalSharedContext instance;
+    return instance;
+  }
+
+  id<MTLDevice> getDevice() { return _device; }
+
+private:
+  MetalSharedContext() {
+    _device = MTLCreateSystemDefaultDevice();
+    if (!_device) {
+      throw std::runtime_error("Failed to create Metal device");
+    }
+  }
+
+  MetalSharedContext(const MetalSharedContext &) = delete;
+  MetalSharedContext &operator=(const MetalSharedContext &) = delete;
+
+  id<MTLDevice> _device;
+};
+
+struct OffscreenRenderContext {
+  id<MTLTexture> texture;
+
+  OffscreenRenderContext(id<MTLDevice> device,
+                         sk_sp<GrDirectContext> skiaContext,
+                         id<MTLCommandQueue> commandQueue, int width,
+                         int height) {
+    // Create a Metal texture descriptor
+    MTLTextureDescriptor *textureDescriptor = [MTLTextureDescriptor
+        texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
+                                     width:width
+                                    height:height
+                                 mipmapped:NO];
+    textureDescriptor.usage =
+        MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+    texture = [device newTextureWithDescriptor:textureDescriptor];
+  }
+};
 
 class MetalContext {
 
@@ -21,28 +72,63 @@ public:
   }
 
   sk_sp<SkSurface> MakeOffscreen(int width, int height) {
-    return SkiaMetalSurfaceFactory::makeOffscreenSurface(_device, &_context,
-                                                         width, height);
+    auto device = MetalSharedContext::getInstance().getDevice();
+    auto ctx = new OffscreenRenderContext(device, _directContext, _commandQueue,
+                                          width, height);
+
+    // Create a GrBackendTexture from the Metal texture
+    GrMtlTextureInfo info;
+    info.fTexture.retain((__bridge void *)ctx->texture);
+    GrBackendTexture backendTexture =
+        GrBackendTextures::MakeMtl(width, height, skgpu::Mipmapped::kNo, info);
+
+    // Create a SkSurface from the GrBackendTexture
+    auto surface = SkSurfaces::WrapBackendTexture(
+        _directContext.get(), backendTexture, kTopLeft_GrSurfaceOrigin, 0,
+        kBGRA_8888_SkColorType, nullptr, nullptr,
+        [](void *addr) { delete (OffscreenRenderContext *)addr; }, ctx);
+
+    return surface;
   }
 
   sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+
     CVPixelBufferRef sampleBuffer = (CVPixelBufferRef)buffer;
-    return SkiaMetalSurfaceFactory::makeTextureFromCVPixelBuffer(&_context,
-                                                                 sampleBuffer);
+    SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat format =
+        SkiaCVPixelBufferUtils::getCVPixelBufferBaseFormat(sampleBuffer);
+    switch (format) {
+    case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::rgb: {
+      // CVPixelBuffer is in any RGB format, single-plane
+      return SkiaCVPixelBufferUtils::RGB::makeSkImageFromCVPixelBuffer(
+          _directContext.get(), sampleBuffer);
+    }
+    case SkiaCVPixelBufferUtils::CVPixelBufferBaseFormat::yuv: {
+      // CVPixelBuffer is in any YUV format, multi-plane
+      return SkiaCVPixelBufferUtils::YUV::makeSkImageFromCVPixelBuffer(
+          _directContext.get(), sampleBuffer);
+    }
+    default:
+      [[unlikely]] {
+        throw std::runtime_error("Failed to convert NativeBuffer to SkImage - "
+                                 "NativeBuffer has unsupported PixelFormat! " +
+                                 std::to_string(static_cast<int>(format)));
+      }
+    }
   }
 
   std::unique_ptr<RNSkia::WindowContext> MakeWindow(CALayer *window, int width,
                                                     int height) {
-    return SkiaMetalSurfaceFactory::makeContext(&_context, window, width,
-                                                height);
+    auto device = MetalSharedContext::getInstance().getDevice();
+    return std::make_unique<MetalWindowContext>(
+        _directContext.get(), device, _commandQueue, window, width, height);
   }
 
-  GrDirectContext *getDirectContext() { return _context.skContext.get(); }
+  GrDirectContext *getDirectContext() { return _directContext.get(); }
 
 private:
-  friend class RNSkia::RNSkiOSPlatformContext;
-  id<MTLDevice> _device;
-  SkiaMetalContext _context;
+  // friend class RNSkia::RNSkiOSPlatformContext;
+  id<MTLCommandQueue> _commandQueue = nullptr;
+  sk_sp<GrDirectContext> _directContext = nullptr;
 
   MetalContext();
 };

package/ios/RNSkia-iOS/MetalContext.mm

@@ -1,5 +1,7 @@
 #include "MetalContext.h"
 
+#include "RNSkLog.h"
+
 #import <MetalKit/MetalKit.h>
 
 #pragma clang diagnostic push
@@ -16,18 +18,17 @@
 #pragma clang diagnostic pop
 
 MetalContext::MetalContext() {
-  _device = MTLCreateSystemDefaultDevice();
-  _context.commandQueue =
-      id<MTLCommandQueue>(CFRetain((GrMTLHandle)[_device newCommandQueue]));
-
+  auto device = MetalSharedContext::getInstance().getDevice();
+  _commandQueue =
+      id<MTLCommandQueue>(CFRetain((GrMTLHandle)[device newCommandQueue]));
   GrMtlBackendContext backendContext = {};
-  backendContext.fDevice.reset((__bridge void *)_device);
-  backendContext.fQueue.reset((__bridge void *)_context.commandQueue);
+  backendContext.fDevice.reset((__bridge void *)device);
+  backendContext.fQueue.reset((__bridge void *)_commandQueue);
   GrContextOptions grContextOptions; // set different options here.
 
   // Create the Skia Direct Context
-  _context.skContext = GrDirectContexts::MakeMetal(backendContext);
-  if (_context.skContext == nullptr) {
+  _directContext = GrDirectContexts::MakeMetal(backendContext);
+  if (_directContext == nullptr) {
     RNSkia::RNSkLogger::logToConsole("Couldn't create a Skia Metal Context");
   }
 }

package/ios/RNSkia-iOS/MetalWindowContext.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#import <MetalKit/MetalKit.h>
+
+#include "WindowContext.h"
+
+class SkiaMetalContext;
+
+class MetalWindowContext : public RNSkia::WindowContext {
+public:
+  MetalWindowContext(GrDirectContext *directContext, id<MTLDevice> device,
+                     id<MTLCommandQueue> commandQueue, CALayer *layer,
+                     int width, int height);
+  ~MetalWindowContext() = default;
+
+  sk_sp<SkSurface> getSurface() override;
+
+  void present() override;
+
+  int getWidth() override {
+    return _layer.frame.size.width * _layer.contentsScale;
+  };
+
+  int getHeight() override {
+    return _layer.frame.size.height * _layer.contentsScale;
+  };
+
+  void resize(int width, int height) override { _skSurface = nullptr; }
+
+private:
+  GrDirectContext *_directContext;
+  id<MTLCommandQueue> _commandQueue;
+  sk_sp<SkSurface> _skSurface = nullptr;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  CAMetalLayer *_layer;
+#pragma clang diagnostic pop
+  id<CAMetalDrawable> _currentDrawable = nil;
+};

package/ios/RNSkia-iOS/MetalWindowContext.mm

@@ -0,0 +1,60 @@
+#include "MetalWindowContext.h"
+
+#include "MetalContext.h"
+#include "RNSkLog.h"
+
+MetalWindowContext::MetalWindowContext(GrDirectContext *directContext,
+                                       id<MTLDevice> device,
+                                       id<MTLCommandQueue> commandQueue,
+                                       CALayer *layer, int width, int height)
+    : _directContext(directContext), _commandQueue(commandQueue) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability-new"
+  _layer = (CAMetalLayer *)layer;
+#pragma clang diagnostic pop
+  _layer.framebufferOnly = NO;
+  _layer.device = device;
+  _layer.opaque = false;
+  _layer.contentsScale = [UIScreen mainScreen].scale;
+  _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
+  _layer.contentsGravity = kCAGravityBottomLeft;
+  _layer.drawableSize = CGSizeMake(width, height);
+}
+
+sk_sp<SkSurface> MetalWindowContext::getSurface() {
+  if (_skSurface) {
+    return _skSurface;
+  }
+
+  // Get the next drawable from the CAMetalLayer
+  _currentDrawable = [_layer nextDrawable];
+  if (!_currentDrawable) {
+    RNSkia::RNSkLogger::logToConsole(
+        "Could not retrieve drawable from CAMetalLayer");
+    return nullptr;
+  }
+
+  // Get the texture from the drawable
+  GrMtlTextureInfo fbInfo;
+  fbInfo.fTexture.retain((__bridge void *)_currentDrawable.texture);
+
+  GrBackendRenderTarget backendRT = GrBackendRenderTargets::MakeMtl(
+      _layer.drawableSize.width, _layer.drawableSize.height, fbInfo);
+
+  _skSurface = SkSurfaces::WrapBackendRenderTarget(
+      _directContext, backendRT, kTopLeft_GrSurfaceOrigin,
+      kBGRA_8888_SkColorType, nullptr, nullptr);
+
+  return _skSurface;
+}
+
+void MetalWindowContext::present() {
+  if (auto dContext = GrAsDirectContext(_skSurface->recordingContext())) {
+    dContext->flushAndSubmit();
+  }
+
+  id<MTLCommandBuffer> commandBuffer([_commandQueue commandBuffer]);
+  [commandBuffer presentDrawable:_currentDrawable];
+  [commandBuffer commit];
+  _skSurface = nullptr;
+}

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.h

@@ -10,8 +10,6 @@
 #include "RNSkPlatformContext.h"
 #include "ViewScreenshotService.h"
 
-#include <jsi/jsi.h>
-
 namespace facebook {
 namespace react {
 class CallInvoker;
@@ -20,35 +18,19 @@ class CallInvoker;
 
 namespace RNSkia {
 
-namespace jsi = facebook::jsi;
-
-static void handleNotification(CFNotificationCenterRef center, void *observer,
-                               CFStringRef name, const void *object,
-                               CFDictionaryRef userInfo);
-
 class RNSkiOSPlatformContext : public RNSkPlatformContext {
 public:
   RNSkiOSPlatformContext(
-      jsi::Runtime *runtime, RCTBridge *bridge,
+      RCTBridge *bridge,
       std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker)
-      : RNSkPlatformContext(runtime, jsCallInvoker,
-                            [[UIScreen mainScreen] scale]) {
-
-    // We need to make sure we invalidate when modules are freed
-    CFNotificationCenterAddObserver(
-        CFNotificationCenterGetLocalCenter(), this, &handleNotification,
-        (__bridge CFStringRef)RCTBridgeWillInvalidateModulesNotification, NULL,
-        CFNotificationSuspensionBehaviorDeliverImmediately);
+      : RNSkPlatformContext(jsCallInvoker, [[UIScreen mainScreen] scale]) {
 
     // Create screenshot manager
     _screenshotService =
         [[ViewScreenshotService alloc] initWithUiManager:bridge.uiManager];
   }
 
-  ~RNSkiOSPlatformContext() {
-    CFNotificationCenterRemoveEveryObserver(
-        CFNotificationCenterGetLocalCenter(), this);
-  }
+  ~RNSkiOSPlatformContext() = default;
 
   void runOnMainThread(std::function<void()>) override;
 
@@ -56,8 +38,16 @@ public:
 
   sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) 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;
+
   void releaseNativeBuffer(uint64_t pointer) override;
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override;
@@ -76,16 +66,10 @@ public:
 #endif
   sk_sp<SkFontMgr> createFontMgr() override;
 
-  void willInvalidateModules() {}
-
 private:
   ViewScreenshotService *_screenshotService;
-};
 
-static void handleNotification(CFNotificationCenterRef center, void *observer,
-                               CFStringRef name, const void *object,
-                               CFDictionaryRef userInfo) {
-  (static_cast<RNSkiOSPlatformContext *>(observer))->willInvalidateModules();
-}
+  SkColorType mtlPixelFormatToSkColorType(MTLPixelFormat pixelFormat);
+};
 
 } // namespace RNSkia