@shopify/react-native-skia 0.1.201 → 0.1.203

package/android/CMakeLists.txt

@@ -9,8 +9,8 @@ set (PACKAGE_NAME "rnskia")
 set (SKIA_LIB "skia")
 set (SKIA_SVG_LIB "svg")
 set (SKIA_SKSHAPER_LIB "skshaper")
-#set (SKIA_SKPARAGRAPH_LIB "skparagraph")
-#set (SKIA_SKUNICODE_LIB "skunicode")
+set (SKIA_SKPARAGRAPH_LIB "skparagraph")
+set (SKIA_SKUNICODE_LIB "skunicode")
 
 # Clear some variables
 unset(LIBRN_DIR CACHE)
@@ -84,7 +84,7 @@ target_include_directories(
         ../cpp/skia/include/utils/
         ../cpp/skia/include/pathops/
         ../cpp/skia/modules/
-        #cpp/skia/modules/skparagraph/include/
+        ../cpp/skia/modules/skparagraph/include/
         ../cpp/skia/include/
         ../cpp/skia
 
@@ -113,11 +113,11 @@ set_property(TARGET svg PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libsvg.a")
 add_library(skshaper STATIC IMPORTED)
 set_property(TARGET skshaper PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskshaper.a")
 
-#add_library(skparagraph STATIC IMPORTED)
-#set_property(TARGET skparagraph PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskparagraph.a")
+add_library(skparagraph STATIC IMPORTED)
+set_property(TARGET skparagraph PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskparagraph.a")
 
-#add_library(skunicode STATIC IMPORTED)
-#set_property(TARGET skunicode PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskunicode.a")
+add_library(skunicode STATIC IMPORTED)
+set_property(TARGET skunicode PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskunicode.a")
 
 
 find_library(
@@ -202,8 +202,8 @@ target_link_libraries(
         ${TURBOMODULES_LIB}
         ${SKIA_SVG_LIB}
         ${SKIA_SKSHAPER_LIB}
-        #${SKIA_SKPARAGRAPH_LIB}
-        #${SKIA_SKUNICODE_LIB}
+        ${SKIA_SKPARAGRAPH_LIB}
+        ${SKIA_SKUNICODE_LIB}
         ${SKIA_LIB}
         -ljnigraphics
         -lGLESv2

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

@@ -9,6 +9,13 @@
 #include <RNSkPlatformContext.h>
 #include <SkiaOpenGLSurfaceFactory.h>
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/ports/SkFontMgr_android.h"
+
+#pragma clang diagnostic pop
+
 namespace RNSkia {
 namespace jsi = facebook::jsi;
 
@@ -41,6 +48,10 @@ public:
     return SkiaOpenGLSurfaceFactory::makeOffscreenSurface(width, height);
   }
 
+  sk_sp<SkFontMgr> createFontMgr() override {
+    return SkFontMgr_New_Android(nullptr);
+  }
+
   void runOnMainThread(std::function<void()> task) override {
     _jniPlatformContext->runTaskOnMainThread(task);
   }

package/cpp/api/JsiSkApi.h

@@ -12,6 +12,8 @@
 #include "JsiSkContourMeasureIter.h"
 #include "JsiSkDataFactory.h"
 #include "JsiSkFont.h"
+#include "JsiSkFontMgr.h"
+#include "JsiSkFontMgrFactory.h"
 #include "JsiSkImage.h"
 #include "JsiSkImageFactory.h"
 #include "JsiSkImageFilter.h"
@@ -39,6 +41,7 @@
 #include "JsiSkShaderFactory.h"
 #include "JsiSkSurfaceFactory.h"
 #include "JsiSkTextBlobFactory.h"
+#include "JsiSkTypeFaceFontProviderFactory.h"
 #include "JsiSkTypeface.h"
 #include "JsiSkTypefaceFactory.h"
 #include "JsiSkVertices.h"
@@ -100,6 +103,11 @@ public:
                             std::make_shared<JsiSkSurfaceFactory>(context));
     installReadonlyProperty("Picture",
                             std::make_shared<JsiSkPictureFactory>(context));
+    installReadonlyProperty("FontMgr",
+                            std::make_shared<JsiSkFontMgrFactory>(context));
+    installReadonlyProperty(
+        "TypefaceFontProvider",
+        std::make_shared<JsiSkTypefaceFontProviderFactory>(context));
   }
 };
 } // namespace RNSkia

package/cpp/api/JsiSkFontMgr.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <memory>
+#include <numeric>
+#include <utility>
+#include <vector>
+
+#include "JsiSkFontStyle.h"
+#include "JsiSkHostObjects.h"
+#include "RNSkLog.h"
+#include <jsi/jsi.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "SkFontMgr.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkFontMgr : public JsiSkWrappingSkPtrHostObject<SkFontMgr> {
+public:
+  EXPORT_JSI_API_TYPENAME(JsiSkFontMgr, "FontMgr")
+
+  JsiSkFontMgr(std::shared_ptr<RNSkPlatformContext> context,
+               sk_sp<SkFontMgr> fontMgr)
+      : JsiSkWrappingSkPtrHostObject(std::move(context), fontMgr) {}
+
+  JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
+
+  JSI_HOST_FUNCTION(getFamilyName) {
+    auto i = static_cast<int>(arguments[0].asNumber());
+    SkString name;
+    getObject()->getFamilyName(i, &name);
+    return jsi::String::createFromUtf8(runtime, name.c_str());
+  }
+
+  JSI_HOST_FUNCTION(matchFamilyStyle) {
+    auto name = arguments[0].asString(runtime).utf8(runtime);
+    auto fontStyle = JsiSkFontStyle::fromValue(runtime, arguments[1]);
+    auto typeface = getObject()->matchFamilyStyle(name.c_str(), *fontStyle);
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkTypeface>(getContext(), typeface));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgr, countFamilies),
+                       JSI_EXPORT_FUNC(JsiSkFontMgr, getFamilyName),
+                       JSI_EXPORT_FUNC(JsiSkFontMgr, matchFamilyStyle))
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkFontMgrFactory.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "SkFontMgr.h"
+#include "include/ports/SkFontMgr_data.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkFontMgrFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(System) {
+    auto context = getContext();
+    static SkOnce once;
+    static sk_sp<SkFontMgr> fontMgr;
+    once([&context, &runtime] { fontMgr = context->createFontMgr(); });
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkFontMgr>(std::move(context), fontMgr));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgrFactory, System))
+
+  explicit JsiSkFontMgrFactory(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkFontStyle.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "SkFontStyle.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkFontStyle : public JsiSkWrappingSharedPtrHostObject<SkFontStyle> {
+public:
+  JSI_API_TYPENAME("FontStyle");
+
+  JsiSkFontStyle(std::shared_ptr<RNSkPlatformContext> context,
+                 const SkFontStyle &fontStyle)
+      : JsiSkWrappingSharedPtrHostObject<SkFontStyle>(
+            std::move(context), std::make_shared<SkFontStyle>(fontStyle)) {}
+
+  /**
+  Returns the underlying object from a host object of this type
+ */
+  static std::shared_ptr<SkFontStyle> fromValue(jsi::Runtime &runtime,
+                                                const jsi::Value &obj) {
+    const auto &object = obj.asObject(runtime);
+    if (object.isHostObject(runtime)) {
+      return object.asHostObject<JsiSkFontStyle>(runtime)->getObject();
+    } else {
+      auto weight =
+          static_cast<int>(object.getProperty(runtime, "weight").asNumber());
+      auto width =
+          static_cast<int>(object.getProperty(runtime, "width").asNumber());
+      auto slant = static_cast<SkFontStyle::Slant>(
+          object.getProperty(runtime, "slant").asNumber());
+      SkFontStyle style(weight, width, slant);
+      return std::make_shared<SkFontStyle>(style);
+    }
+  }
+
+  /**
+  Returns the jsi object from a host object of this type
+ */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            const SkFontStyle &fontStyle) {
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkFontStyle>(std::move(context), fontStyle));
+  }
+};
+} // namespace RNSkia

package/cpp/api/JsiSkTypeFaceFontProvider.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkFontStyle.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkTypeface.h"
+
+#include "RNSkLog.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "SkFont.h"
+#include "skparagraph/include/TypefaceFontProvider.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+namespace para = skia::textlayout;
+
+class JsiSkTypefaceFontProvider
+    : public JsiSkWrappingSkPtrHostObject<para::TypefaceFontProvider> {
+public:
+  EXPORT_JSI_API_TYPENAME(JsiSkTypefaceFontProvider, "FontMgr")
+  JSI_EXPORT_FUNCTIONS(
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, dispose),
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, registerFont),
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, matchFamilyStyle),
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, countFamilies),
+      JSI_EXPORT_FUNC(JsiSkTypefaceFontProvider, getFamilyName))
+
+  JSI_HOST_FUNCTION(registerFont) {
+    sk_sp<SkTypeface> typeface =
+        JsiSkTypeface::fromValue(runtime, arguments[0]);
+    SkString familyName(arguments[1].asString(runtime).utf8(runtime).c_str());
+    auto result = getObject()->registerTypeface(typeface, familyName);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(matchFamilyStyle) {
+    auto name = arguments[0].asString(runtime).utf8(runtime);
+    auto fontStyle = JsiSkFontStyle::fromValue(runtime, arguments[1]);
+    auto typeface = getObject()->matchFamilyStyle(name.c_str(), *fontStyle);
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkTypeface>(getContext(), typeface));
+  }
+
+  JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
+
+  JSI_HOST_FUNCTION(getFamilyName) {
+    auto i = static_cast<int>(arguments[0].asNumber());
+    SkString name;
+    getObject()->getFamilyName(i, &name);
+    return jsi::String::createFromUtf8(runtime, name.c_str());
+  }
+
+  JsiSkTypefaceFontProvider(std::shared_ptr<RNSkPlatformContext> context,
+                            sk_sp<para::TypefaceFontProvider> tfProvider)
+      : JsiSkWrappingSkPtrHostObject(std::move(context),
+                                     std::move(tfProvider)) {}
+
+  /**
+   Returns the jsi object from a host object of this type
+  */
+  static jsi::Value toValue(jsi::Runtime &runtime,
+                            std::shared_ptr<RNSkPlatformContext> context,
+                            sk_sp<para::TypefaceFontProvider> tfProvider) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
+                     std::move(context), std::move(tfProvider)));
+  }
+};
+
+} // namespace RNSkia

package/cpp/api/JsiSkTypeFaceFontProviderFactory.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkData.h"
+#include "JsiSkHostObjects.h"
+#include "JsiSkTypefaceFontProvider.h"
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+namespace para = skia::textlayout;
+
+class JsiSkTypefaceFontProviderFactory : public JsiSkHostObject {
+public:
+  JSI_HOST_FUNCTION(Make) {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
+                     getContext(), sk_make_sp<para::TypefaceFontProvider>()));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFontProviderFactory, Make))
+
+  explicit JsiSkTypefaceFontProviderFactory(
+      std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(std::move(context)) {}
+};
+
+} // namespace RNSkia

package/cpp/rnskia/RNSkPlatformContext.h

@@ -15,6 +15,7 @@
 #pragma clang diagnostic ignored "-Wdocumentation"
 
 #include "SkData.h"
+#include "SkFontMgr.h"
 #include "SkImage.h"
 #include "SkStream.h"
 #include "SkSurface.h"
@@ -132,6 +133,11 @@ public:
    */
   virtual sk_sp<SkSurface> makeOffscreenSurface(int width, int height) = 0;
 
+  /**
+   * Return the Platform specific font manager
+   */
+  virtual sk_sp<SkFontMgr> createFontMgr() = 0;
+
   /**
    * Creates an skImage containing the screenshot of a native view and its
    * children.

package/cpp/rnskia/RNSkView.h

@@ -93,6 +93,7 @@ public:
                               float height)
       : RNSkCanvasProvider(requestRedraw), _width(width), _height(height) {
     _surface = context->makeOffscreenSurface(_width, _height);
+    _pd = context->getPixelDensity();
   }
 
   /**
@@ -101,8 +102,9 @@ public:
   sk_sp<SkImage> makeSnapshot(SkRect *bounds) {
     sk_sp<SkImage> image;
     if (bounds != nullptr) {
-      SkIRect b = SkIRect::MakeXYWH(bounds->x(), bounds->y(), bounds->width(),
-                                    bounds->height());
+      SkIRect b =
+          SkIRect::MakeXYWH(bounds->x() * _pd, bounds->y() * _pd,
+                            bounds->width() * _pd, bounds->height() * _pd);
       image = _surface->makeImageSnapshot(b);
     } else {
       image = _surface->makeImageSnapshot();
@@ -131,6 +133,7 @@ public:
 private:
   float _width;
   float _height;
+  float _pd = 1.0f;
   sk_sp<SkSurface> _surface;
 };
 

package/cpp/skia/include/core/SkColorTable.h

@@ -19,7 +19,7 @@ class SkWriteBuffer;
  * of `SkColorFilters::Table`, and provides a way to share the table data between client code and
  * the returned SkColorFilter. Once created, an SkColorTable is immutable.
 */
-class SkColorTable : public SkRefCnt {
+class SK_API SkColorTable : public SkRefCnt {
 public:
     // Creates a new SkColorTable with 'table' used for all four channels. The table is copied into
     // the SkColorTable.

package/ios/RNSkia-iOS/RNSkMetalCanvasProvider.h

@@ -6,13 +6,12 @@
 #import <MetalKit/MetalKit.h>
 #import <QuartzCore/CAMetalLayer.h>
 
-using MetalRenderContext = struct {
-  id<MTLCommandQueue> commandQueue;
-  sk_sp<GrDirectContext> skContext;
-};
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import <include/gpu/GrDirectContext.h>
 
-static std::unordered_map<std::thread::id, std::shared_ptr<MetalRenderContext>>
-    renderContexts;
+#pragma clang diagnostic pop
 
 class RNSkMetalCanvasProvider : public RNSkia::RNSkCanvasProvider {
 public:
@@ -27,17 +26,9 @@ public:
   bool renderToCanvas(const std::function<void(SkCanvas *)> &cb) override;
 
   void setSize(int width, int height);
-
   CALayer *getLayer();
 
 private:
-  /**
-   * To be able to use static contexts (and avoid reloading the skia context for
-   * each new view, we track the Skia drawing context per thread.
-   * @return The drawing context for the current thread
-   */
-  static std::shared_ptr<MetalRenderContext> getMetalRenderContext();
-
   std::shared_ptr<RNSkia::RNSkPlatformContext> _context;
   float _width = -1;
   float _height = -1;

package/ios/RNSkia-iOS/RNSkMetalCanvasProvider.mm

@@ -1,5 +1,6 @@
 #import <RNSkLog.h>
 #import <RNSkMetalCanvasProvider.h>
+#import <SkiaMetalSurfaceFactory.h>
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -14,19 +15,6 @@
 
 #pragma clang diagnostic pop
 
-/** Static members */
-std::shared_ptr<MetalRenderContext>
-RNSkMetalCanvasProvider::getMetalRenderContext() {
-  auto threadId = std::this_thread::get_id();
-  if (renderContexts.count(threadId) == 0) {
-    auto drawingContext = std::make_shared<MetalRenderContext>();
-    drawingContext->commandQueue = nullptr;
-    drawingContext->skContext = nullptr;
-    renderContexts.emplace(threadId, drawingContext);
-  }
-  return renderContexts.at(threadId);
-}
-
 RNSkMetalCanvasProvider::RNSkMetalCanvasProvider(
     std::function<void()> requestRedraw,
     std::shared_ptr<RNSkia::RNSkPlatformContext> context)
@@ -35,11 +23,8 @@ RNSkMetalCanvasProvider::RNSkMetalCanvasProvider(
 #pragma clang diagnostic ignored "-Wunguarded-availability-new"
   _layer = [CAMetalLayer layer];
 #pragma clang diagnostic pop
-
-  auto device = MTLCreateSystemDefaultDevice();
-
   _layer.framebufferOnly = NO;
-  _layer.device = device;
+  _layer.device = MTLCreateSystemDefaultDevice();
   _layer.opaque = false;
   _layer.contentsScale = _context->getPixelDensity();
   _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
@@ -87,52 +72,18 @@ bool RNSkMetalCanvasProvider::renderToCanvas(
       return false;
     }
   }
-
-  // Get render context for current thread
-  auto renderContext = getMetalRenderContext();
-
-  if (renderContext->skContext == nullptr) {
-    auto device = MTLCreateSystemDefaultDevice();
-    renderContext->commandQueue =
-        id<MTLCommandQueue>(CFRetain((GrMTLHandle)[device newCommandQueue]));
-    renderContext->skContext = GrDirectContext::MakeMetal(
-        (__bridge void *)device, (__bridge void *)renderContext->commandQueue);
-  }
-
   // Wrap in auto release pool since we want the system to clean up after
   // rendering and not wait until later - we've seen some example of memory
   // usage growing very fast in the simulator without this.
   @autoreleasepool {
-
-    /* It is super important that we use the pattern of calling nextDrawable
-     inside this autoreleasepool and not depend on Skia's
-     SkSurface::MakeFromCAMetalLayer to encapsulate since we're seeing a lot of
-     drawables leaking if they're not done this way.
-
-     This is now reverted from:
-     (https://github.com/Shopify/react-native-skia/commit/2e2290f8e6dfc6921f97b79f779d920fbc1acceb)
-     back to the original implementation.
-     */
     id<CAMetalDrawable> currentDrawable = [_layer nextDrawable];
     if (currentDrawable == nullptr) {
       return false;
     }
 
-    GrMtlTextureInfo fbInfo;
-    fbInfo.fTexture.retain((__bridge void *)currentDrawable.texture);
-
-    GrBackendRenderTarget backendRT(_layer.drawableSize.width,
-                                    _layer.drawableSize.height, 1, fbInfo);
-
-    auto skSurface = SkSurfaces::WrapBackendRenderTarget(
-        renderContext->skContext.get(), backendRT, kTopLeft_GrSurfaceOrigin,
-        kBGRA_8888_SkColorType, nullptr, nullptr);
-
-    if (skSurface == nullptr || skSurface->getCanvas() == nullptr) {
-      RNSkia::RNSkLogger::logToConsole(
-          "Skia surface could not be created from parameters.");
-      return false;
-    }
+    auto skSurface = SkiaMetalSurfaceFactory::makeWindowedSurface(
+        currentDrawable.texture, _layer.drawableSize.width,
+        _layer.drawableSize.height);
 
     SkCanvas *canvas = skSurface->getCanvas();
     cb(canvas);
@@ -140,11 +91,11 @@ bool RNSkMetalCanvasProvider::renderToCanvas(
     skSurface->flushAndSubmit();
 
     id<MTLCommandBuffer> commandBuffer(
-        [renderContext->commandQueue commandBuffer]);
+        [ThreadContextHolder::ThreadSkiaMetalContext
+                .commandQueue commandBuffer]);
     [commandBuffer presentDrawable:currentDrawable];
     [commandBuffer commit];
   }
-
   return true;
 };
 

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.h

@@ -64,6 +64,7 @@ public:
 
   void raiseError(const std::exception &err) override;
   sk_sp<SkSurface> makeOffscreenSurface(int width, int height) override;
+  sk_sp<SkFontMgr> createFontMgr() override;
 
   void willInvalidateModules() {
     // We need to do some house-cleaning here!

package/ios/RNSkia-iOS/RNSkiOSPlatformContext.mm

@@ -4,13 +4,16 @@
 #include <thread>
 #include <utility>
 
-#include <SkiaMetalRenderer.h>
+#include <SkiaMetalSurfaceFactory.h>
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
+#include "SkFontMgr.h"
 #include "SkSurface.h"
 
+#include "include/ports/SkFontMgr_mac_ct.h"
+
 #pragma clang diagnostic pop
 
 namespace RNSkia {
@@ -59,7 +62,11 @@ void RNSkiOSPlatformContext::raiseError(const std::exception &err) {
 
 sk_sp<SkSurface> RNSkiOSPlatformContext::makeOffscreenSurface(int width,
                                                               int height) {
-  return MakeOffscreenMetalSurface(width, height);
+  return SkiaMetalSurfaceFactory::makeOffscreenSurface(width, height);
+}
+
+sk_sp<SkFontMgr> RNSkiOSPlatformContext::createFontMgr() {
+  return SkFontMgr_New_CoreText(nullptr);
 }
 
 void RNSkiOSPlatformContext::runOnMainThread(std::function<void()> func) {

package/ios/RNSkia-iOS/SkiaMetalSurfaceFactory.h

@@ -0,0 +1,31 @@
+#import <MetalKit/MetalKit.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#import "SkCanvas.h"
+#import <include/gpu/GrDirectContext.h>
+
+#pragma clang diagnostic pop
+
+using SkiaMetalContext = struct SkiaMetalContext {
+  id<MTLCommandQueue> commandQueue = nullptr;
+  sk_sp<GrDirectContext> skContext = nullptr;
+};
+
+class ThreadContextHolder {
+public:
+  static thread_local SkiaMetalContext ThreadSkiaMetalContext;
+};
+
+class SkiaMetalSurfaceFactory {
+public:
+  static sk_sp<SkSurface> makeWindowedSurface(id<MTLTexture> texture, int width,
+                                              int height);
+  static sk_sp<SkSurface> makeOffscreenSurface(int width, int height);
+
+private:
+  static id<MTLDevice> device;
+  static bool
+  createSkiaDirectContextIfNecessary(SkiaMetalContext *threadContext);
+};