@shopify/react-native-skia 0.1.151 → 0.1.152

package/android/CMakeLists.txt

@@ -34,18 +34,17 @@ add_library(
         SHARED
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniLoad.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniSkiaManager.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/jni/JniSkiaDrawView.cpp"
+
         "${PROJECT_SOURCE_DIR}/cpp/jni/JniPlatformContext.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkDrawViewImpl.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkOpenGLCanvasProvider.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/SkiaOpenGLRenderer.cpp"
-        
+
         "${PROJECT_SOURCE_DIR}/cpp/jsi/JsiHostObject.cpp"
 
         "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkManager.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkDrawView.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkJsView.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkDispatchQueue.cpp"
 
-
         "${PROJECT_SOURCE_DIR}/cpp/api/third_party/CSSColorParser.cpp"
         
 )

package/android/cpp/jni/JniLoad.cpp

@@ -1,13 +1,15 @@
 #include "JniPlatformContext.h"
 #include "JniSkiaDrawView.h"
+#include "JniSkiaPictureView.h"
 #include "JniSkiaManager.h"
 #include <fbjni/fbjni.h>
 #include <jni.h>
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
-    return facebook::jni::initialize(vm, [] {
-        RNSkia::JniSkiaManager::registerNatives();
-        RNSkia::JniSkiaDrawView::registerNatives();
-        RNSkia::JniPlatformContext::registerNatives();
-    });
+  return facebook::jni::initialize(vm, [] {
+      RNSkia::JniSkiaManager::registerNatives();
+      RNSkia::JniSkiaDrawView::registerNatives();
+      RNSkia::JniSkiaPictureView::registerNatives();
+      RNSkia::JniPlatformContext::registerNatives();
+  });
 }

package/android/cpp/jni/JniSkiaManager.cpp

@@ -16,13 +16,8 @@ using namespace facebook;
 void JniSkiaManager::registerNatives() {
     registerHybrid({
         makeNativeMethod("initHybrid", JniSkiaManager::initHybrid),
-        makeNativeMethod(
-            "initializeRuntime", JniSkiaManager::initializeRuntime),
-        makeNativeMethod("registerSkiaView", JniSkiaManager::registerSkiaView),
-        makeNativeMethod(
-            "unregisterSkiaView", JniSkiaManager::unregisterSkiaView),
-        makeNativeMethod(
-            "invalidate", JniSkiaManager::invalidate),
+        makeNativeMethod("initializeRuntime", JniSkiaManager::initializeRuntime),
+        makeNativeMethod("invalidate", JniSkiaManager::invalidate),
     });
 }
 
@@ -46,12 +41,4 @@ void JniSkiaManager::initializeRuntime() {
     _skManager = std::make_shared<RNSkManager>(_jsRuntime, _jsCallInvoker, _context);
 }
 
-void JniSkiaManager::registerSkiaView(int viewTag, JniSkiaDrawView *skiaView) {
-    _skManager->registerSkiaDrawView(viewTag, skiaView->getDrawViewImpl());
-}
-
-void JniSkiaManager::unregisterSkiaView(int viewTag) {
-    _skManager->unregisterSkiaDrawView(viewTag);
-}
-
 } // namespace RNSkia

package/android/cpp/jni/include/JniSkiaBaseView.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <memory>
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+
+#include <JniSkiaManager.h>
+
+namespace RNSkia {
+    using namespace facebook;
+    using namespace jni;
+
+    class JniSkiaBaseView {
+    public:
+        JniSkiaBaseView(jni::alias_ref<JniSkiaManager::javaobject> skiaManager,
+                        std::shared_ptr<RNSkBaseAndroidView> skiaView) :
+                _manager(skiaManager->cthis()),
+                _skiaView(skiaView) {}
+
+        ~JniSkiaBaseView() {}
+
+        std::shared_ptr<RNSkManager> getSkiaManager() { return _manager->getSkiaManager(); };
+
+    protected:
+        virtual void updateTouchPoints(jni::JArrayDouble touches) {
+          _skiaView->updateTouchPoints(touches);
+        }
+
+        virtual void surfaceAvailable(jobject surface, int width, int height) {
+          _skiaView->surfaceAvailable(surface, width, height);
+        }
+
+        virtual void surfaceSizeChanged(int width, int height) {
+          _skiaView->surfaceSizeChanged(width, height);
+        }
+
+        virtual void surfaceDestroyed() {
+          _skiaView->surfaceDestroyed();
+        }
+
+        virtual void setMode(std::string mode) {
+          _skiaView->setMode(mode);
+        }
+
+        virtual void setDebugMode(bool show) {
+          _skiaView->setShowDebugInfo(show);
+        }
+
+        virtual void registerView(int nativeId) {
+          getSkiaManager()->registerSkiaView(nativeId,
+                                             _skiaView->getSkiaView());
+        }
+
+        virtual void unregisterView() {
+          getSkiaManager()->setSkiaView(_skiaView->getSkiaView()->getNativeId(), nullptr);
+          getSkiaManager()->unregisterSkiaView(
+                  _skiaView->getSkiaView()->getNativeId());
+          _skiaView->viewDidUnmount();
+        }
+
+    private:
+        JniSkiaManager *_manager;
+        std::shared_ptr<RNSkBaseAndroidView> _skiaView;
+    };
+
+} // namespace RNSkia

package/android/cpp/jni/include/JniSkiaDrawView.h

@@ -1,78 +1,95 @@
 #pragma once
 
-#include <map>
 #include <memory>
-#include <thread>
-#include <string>
 
 #include <fbjni/fbjni.h>
 #include <jni.h>
 #include <jsi/jsi.h>
-#include <thread>
 
-#include <RNSkDrawView.h>
+#include <RNSkJsView.h>
+#include <RNSkAndroidView.h>
+#include <JniSkiaBaseView.h>
 #include <JniSkiaManager.h>
-#include <JniSkiaDrawView.h>
 
-#include <RNSkDrawViewImpl.h>
+#include <android/native_window.h>
+#include <android/native_window_jni.h>
+#include <fbjni/detail/Hybrid.h>
 
-#include <SkSurface.h>
-#include <SkRefCnt.h>
-#include <gpu/GrBackendSurface.h>
-#include <gpu/GrDirectContext.h>
-
-class SkPicture;
-class ANativeWindow;
-
-namespace RNSkia
-{
+namespace RNSkia {
     using namespace facebook;
+    using namespace jni;
 
-    using JavaSkiaManager = jni::alias_ref<JniSkiaManager::javaobject>;
-
-    class JniSkiaDrawView : public jni::HybridClass<JniSkiaDrawView>
-    {
+    class JniSkiaDrawView
+            : public HybridClass<JniSkiaDrawView>, public JniSkiaBaseView {
     public:
         static auto constexpr kJavaDescriptor = "Lcom/shopify/reactnative/skia/SkiaDrawView;";
-        static auto constexpr TAG = "ReactNativeSkia";
 
-        static jni::local_ref<jhybriddata> initHybrid(
-                jni::alias_ref<jhybridobject>,
-                JavaSkiaManager);
+        static jni::local_ref<jhybriddata>
+        initHybrid(jni::alias_ref<jhybridobject> jThis,
+                   jni::alias_ref<JniSkiaManager::javaobject> skiaManager) {
+          return makeCxxInstance(jThis, skiaManager);
+        }
 
-        static void registerNatives();
+        static void registerNatives() {
+          registerHybrid({
+                                 makeNativeMethod("initHybrid", JniSkiaDrawView::initHybrid),
+                                 makeNativeMethod("surfaceAvailable",
+                                                  JniSkiaDrawView::surfaceAvailable),
+                                 makeNativeMethod("surfaceDestroyed",
+                                                  JniSkiaDrawView::surfaceDestroyed),
+                                 makeNativeMethod("surfaceSizeChanged",
+                                                  JniSkiaDrawView::surfaceSizeChanged),
+                                 makeNativeMethod("setMode", JniSkiaDrawView::setMode),
+                                 makeNativeMethod("setDebugMode", JniSkiaDrawView::setDebugMode),
+                                 makeNativeMethod("updateTouchPoints",
+                                                  JniSkiaDrawView::updateTouchPoints),
+                                 makeNativeMethod("registerView", JniSkiaDrawView::registerView),
+                                 makeNativeMethod("unregisterView", JniSkiaDrawView::unregisterView)
+                         });
+        }
 
-        void surfaceAvailable(jobject, int, int);
-        void surfaceDestroyed();
-        void surfaceSizeChanged(int, int);
+    protected:
+        void updateTouchPoints(jni::JArrayDouble touches) override {
+          JniSkiaBaseView::updateTouchPoints(touches);
+        }
 
-        void updateTouchPoints(jni::JArrayDouble touches);
+        void surfaceAvailable(jobject surface, int width, int height) override {
+          JniSkiaBaseView::surfaceAvailable(surface, width, height);
+        }
 
-        ~JniSkiaDrawView();
+        void surfaceSizeChanged(int width, int height) override {
+          JniSkiaBaseView::surfaceSizeChanged(width, height);
+        }
 
-        std::shared_ptr<RNSkDrawView> getDrawViewImpl() { return _drawView; }
+        void surfaceDestroyed() override { JniSkiaBaseView::surfaceDestroyed(); }
 
-        void releaseSurface();
+        void setMode(std::string mode) override {
+          JniSkiaBaseView::setMode(mode);
+        }
 
-    protected:
-        void setMode(std::string mode);
-        void setDebugMode(bool show);
+        void setDebugMode(bool show) override {
+          JniSkiaBaseView::setDebugMode(show);
+        }
 
-    private:
-        friend HybridBase;
+        void registerView(int nativeId) override {
+          JniSkiaBaseView::registerView(nativeId);
+        }
 
-        std::shared_ptr<RNSkDrawViewImpl> _drawView;
+        void unregisterView() override {
+          JniSkiaBaseView::unregisterView();
+        }
 
-        jni::global_ref<JniSkiaDrawView::javaobject> javaPart_;
+    private:
+        friend HybridBase;
 
-        explicit JniSkiaDrawView(
-                jni::alias_ref<JniSkiaDrawView::jhybridobject> jThis,
-                JavaSkiaManager skiaManager)
-                : javaPart_(jni::make_global(jThis)),
-                  _drawView(std::make_shared<RNSkDrawViewImpl>(skiaManager->cthis()->getPlatformContext(), [this]() {
-                      releaseSurface();
-                  })) {
+        explicit JniSkiaDrawView(jni::alias_ref<jhybridobject> jThis,
+                                 jni::alias_ref<JniSkiaManager::javaobject> skiaManager) :
+                JniSkiaBaseView(skiaManager,
+                                std::make_shared<RNSkAndroidView<RNSkia::RNSkJsView>>(
+                                        skiaManager->cthis()->getPlatformContext())) {
         }
+
+        jni::global_ref<javaobject> javaPart_;
     };
 
 } // namespace RNSkia

package/android/cpp/jni/include/JniSkiaManager.h

@@ -7,12 +7,14 @@
 #include <memory>
 
 #include <JniPlatformContext.h>
-#include <RNSkPlatformContextImpl.h>
-
+#include <RNSkAndroidPlatformContext.h>
+#include <RNSkManager.h>
 #include <RNSkLog.h>
 
 namespace RNSkia {
+
 class RNSkManager;
+
 using namespace facebook;
 
 using JSCallInvokerHolder =
@@ -20,8 +22,6 @@ using JSCallInvokerHolder =
 
 using JavaPlatformContext = jni::alias_ref<JniPlatformContext::javaobject>;
 
-class JniSkiaDrawView;
-
 class JniSkiaManager : public jni::HybridClass<JniSkiaManager> {
    public:
     static auto constexpr kJavaDescriptor = "Lcom/shopify/reactnative/skia/SkiaManager;";
@@ -48,14 +48,12 @@ class JniSkiaManager : public jni::HybridClass<JniSkiaManager> {
         : _javaPart(jni::make_global(jThis)),
           _jsRuntime(runtime),
           _jsCallInvoker(jsCallInvoker),
-          _context(std::make_shared<RNSkPlatformContextImpl>(platformContext, runtime, jsCallInvoker)) {
+          _context(std::make_shared<RNSkAndroidPlatformContext>(platformContext, runtime, jsCallInvoker)) {
 
     }
 
-    void registerSkiaView(int viewTag, JniSkiaDrawView *skiaView);
-    void unregisterSkiaView(int viewTag);
-
-    std::shared_ptr<RNSkPlatformContextImpl> getPlatformContext() { return _context; }
+    std::shared_ptr<RNSkAndroidPlatformContext> getPlatformContext() { return _context; }
+    std::shared_ptr<RNSkManager> getSkiaManager() { return _skManager; }
 
     void invalidate() {
         _context->stopDrawLoop();
@@ -73,7 +71,7 @@ class JniSkiaManager : public jni::HybridClass<JniSkiaManager> {
 
     jsi::Runtime *_jsRuntime;
     std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;
-    std::shared_ptr<RNSkPlatformContextImpl> _context;
+    std::shared_ptr<RNSkAndroidPlatformContext> _context;
 
     void initializeRuntime();
 };

package/android/cpp/jni/include/JniSkiaPictureView.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <memory>
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+
+#include <RNSkPictureView.h>
+#include <RNSkAndroidView.h>
+#include <JniSkiaBaseView.h>
+#include <JniSkiaManager.h>
+
+#include <android/native_window.h>
+#include <android/native_window_jni.h>
+#include <fbjni/detail/Hybrid.h>
+
+namespace RNSkia {
+    using namespace facebook;
+    using namespace jni;
+
+    class JniSkiaPictureView
+            : public HybridClass<JniSkiaPictureView>, public JniSkiaBaseView {
+    public:
+        static auto constexpr kJavaDescriptor = "Lcom/shopify/reactnative/skia/SkiaPictureView;";
+
+        static jni::local_ref<jhybriddata>
+        initHybrid(jni::alias_ref<jhybridobject> jThis,
+                   jni::alias_ref<JniSkiaManager::javaobject> skiaManager) {
+          return makeCxxInstance(jThis, skiaManager);
+        }
+
+        static void registerNatives() {
+          registerHybrid({
+                                 makeNativeMethod("initHybrid", JniSkiaPictureView::initHybrid),
+                                 makeNativeMethod("surfaceAvailable",
+                                                  JniSkiaPictureView::surfaceAvailable),
+                                 makeNativeMethod("surfaceDestroyed",
+                                                  JniSkiaPictureView::surfaceDestroyed),
+                                 makeNativeMethod("surfaceSizeChanged",
+                                                  JniSkiaPictureView::surfaceSizeChanged),
+                                 makeNativeMethod("setMode", JniSkiaPictureView::setMode),
+                                 makeNativeMethod("setDebugMode", JniSkiaPictureView::setDebugMode),
+                                 makeNativeMethod("updateTouchPoints",
+                                                  JniSkiaPictureView::updateTouchPoints),
+                                 makeNativeMethod("registerView", JniSkiaPictureView::registerView),
+                                 makeNativeMethod("unregisterView",
+                                                  JniSkiaPictureView::unregisterView)
+                         });
+        }
+
+    protected:
+        void updateTouchPoints(jni::JArrayDouble touches) override {
+          JniSkiaBaseView::updateTouchPoints(touches);
+        }
+
+        void surfaceAvailable(jobject surface, int width, int height) override {
+          JniSkiaBaseView::surfaceAvailable(surface, width, height);
+        }
+
+        void surfaceSizeChanged(int width, int height) override {
+          JniSkiaBaseView::surfaceSizeChanged(width, height);
+        }
+
+        void surfaceDestroyed() override { JniSkiaBaseView::surfaceDestroyed(); }
+
+        void setMode(std::string mode) override {
+          JniSkiaBaseView::setMode(mode);
+        }
+
+        void setDebugMode(bool show) override {
+          JniSkiaBaseView::setDebugMode(show);
+        }
+
+        void registerView(int nativeId) override {
+          JniSkiaBaseView::registerView(nativeId);
+        }
+
+        void unregisterView() override {
+          JniSkiaBaseView::unregisterView();
+        }
+
+    private:
+        friend HybridBase;
+
+        explicit JniSkiaPictureView(jni::alias_ref<jhybridobject> jThis,
+                                    jni::alias_ref<JniSkiaManager::javaobject> skiaManager) :
+                JniSkiaBaseView(skiaManager,
+                                std::make_shared<RNSkAndroidView<RNSkia::RNSkPictureView>>(
+                                        skiaManager->cthis()->getPlatformContext())) {
+        }
+
+        jni::global_ref<javaobject> javaPart_;
+    };
+
+} // namespace RNSkia

package/android/cpp/rnskia-android/{RNSkPlatformContextImpl.h → RNSkAndroidPlatformContext.h}

@@ -11,11 +11,11 @@
 namespace RNSkia {
     using namespace facebook;
 
-    class RNSkPlatformContextImpl: public RNSkPlatformContext {
+    class RNSkAndroidPlatformContext: public RNSkPlatformContext {
     public:
-        RNSkPlatformContextImpl(JniPlatformContext* jniPlatformContext,
-                                jsi::Runtime *runtime,
-                                std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker) :
+        RNSkAndroidPlatformContext(JniPlatformContext* jniPlatformContext,
+                                   jsi::Runtime *runtime,
+                                   std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker) :
             RNSkPlatformContext(runtime,
                                 jsCallInvoker,
                                 jniPlatformContext->getPixelDensity()),

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

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <RNSkJsView.h>
+#include <RNSkOpenGLCanvasProvider.h>
+#include <android/native_window.h>
+
+namespace RNSkia {
+
+    class RNSkBaseAndroidView {
+    public:
+        virtual void surfaceAvailable(jobject surface, int width, int height) = 0;
+
+        virtual void surfaceDestroyed() = 0;
+
+        virtual void surfaceSizeChanged(int width, int height) = 0;
+
+        virtual float getPixelDensity() = 0;
+
+        virtual void updateTouchPoints(jni::JArrayDouble touches) = 0;
+
+        virtual void setMode(std::string mode) = 0;
+
+        virtual void setShowDebugInfo(bool show) = 0;
+
+        virtual void viewDidUnmount() = 0;
+
+        virtual std::shared_ptr<RNSkView> getSkiaView() = 0;
+    };
+
+    template<typename T>
+    class RNSkAndroidView
+            : public T, public RNSkBaseAndroidView {
+    public:
+        RNSkAndroidView(
+                std::shared_ptr<RNSkia::RNSkPlatformContext> context) :
+                T(context,
+                  std::make_shared<RNSkOpenGLCanvasProvider>(
+                          std::bind(&RNSkia::RNSkView::requestRedraw, this),
+                          context)
+                ) {}
+
+        void surfaceAvailable(jobject surface, int width, int height) override {
+          std::static_pointer_cast<RNSkOpenGLCanvasProvider>(
+                  T::getCanvasProvider())->surfaceAvailable(surface, width, height);
+        }
+
+        void surfaceDestroyed() override {
+          std::static_pointer_cast<RNSkOpenGLCanvasProvider>(
+                  T::getCanvasProvider())->surfaceDestroyed();
+        }
+
+        void surfaceSizeChanged(int width, int height) override {
+          std::static_pointer_cast<RNSkOpenGLCanvasProvider>(
+                  T::getCanvasProvider())->surfaceSizeChanged(width, height);
+        }
+
+        float getPixelDensity() override {
+          return T::getPlatformContext()->getPixelDensity();
+        }
+
+        void setMode(std::string mode) override {
+          if (mode.compare("continuous") == 0) {
+            T::setDrawingMode(RNSkDrawingMode::Continuous);
+          } else {
+            T::setDrawingMode(RNSkDrawingMode::Default);
+          }
+        }
+
+        void setShowDebugInfo(bool show) override {
+          T::setShowDebugOverlays(show);
+        }
+
+        void viewDidUnmount() override {
+          T::endDrawingLoop();
+        }
+
+        void updateTouchPoints(jni::JArrayDouble touches) override {
+          // Create touch points
+          std::vector<RNSkia::RNSkTouchInfo> points;
+          auto pin = touches.pin();
+          auto scale = getPixelDensity();
+          points.reserve(pin.size() / 5);
+          for (size_t i = 0; i < pin.size(); i += 5) {
+            RNSkTouchInfo point;
+            point.x = pin[i] / scale;
+            point.y = pin[i + 1] / scale;
+            point.force = pin[i + 2];
+            point.type = (RNSkia::RNSkTouchInfo::TouchType) pin[i + 3];
+            point.id = pin[i + 4];
+            points.push_back(point);
+          }
+          T::updateTouchState(points);
+        }
+
+        std::shared_ptr<RNSkView> getSkiaView() override {
+          return T::shared_from_this();
+        }
+
+    };
+}

package/android/cpp/rnskia-android/RNSkOpenGLCanvasProvider.cpp

@@ -0,0 +1,91 @@
+#include <RNSkOpenGLCanvasProvider.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkSurface.h>
+#include <SkCanvas.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+  RNSkOpenGLCanvasProvider::RNSkOpenGLCanvasProvider(
+          std::function<void()> requestRedraw,
+          std::shared_ptr<RNSkia::RNSkPlatformContext> context):
+          RNSkCanvasProvider(requestRedraw),
+          _context(context) {}
+
+  RNSkOpenGLCanvasProvider::~RNSkOpenGLCanvasProvider() {}
+
+  float RNSkOpenGLCanvasProvider::getScaledWidth() {
+    return _width;
+  }
+
+  float RNSkOpenGLCanvasProvider::getScaledHeight() {
+    return _height;
+  }
+
+  void RNSkOpenGLCanvasProvider::renderToCanvas(const std::function<void(SkCanvas *)> &cb) {
+    if(_renderer != nullptr) {
+      _renderer->run(cb, _width, _height);
+    }
+  }
+
+  void RNSkOpenGLCanvasProvider::surfaceAvailable(jobject surface, int width, int height) {
+    _width = width;
+    _height = height;
+
+    if (_renderer == nullptr)
+    {
+      // Create renderer!
+      _renderer = std::make_unique<SkiaOpenGLRenderer>(surface);
+
+      // Redraw
+      _requestRedraw();
+    }
+  }
+  void RNSkOpenGLCanvasProvider::surfaceDestroyed()  {
+    if (_renderer != nullptr)
+    {
+      // teardown
+      _renderer->teardown();
+
+      // Teardown renderer on the render thread since OpenGL demands
+      // same thread access for OpenGL contexts.
+      std::condition_variable cv;
+      std::mutex m;
+      std::unique_lock<std::mutex> lock(m);
+
+      _context->runOnRenderThread([&cv, &m, weakSelf = weak_from_this()]() {
+          // Lock
+          std::unique_lock<std::mutex> lock(m);
+
+          auto self = weakSelf.lock();
+          if(self) {
+            if(self->_renderer != nullptr) {
+              self->_renderer->run(nullptr, 0, 0);
+            }
+            // Remove renderer
+            self->_renderer = nullptr;
+          }
+          cv.notify_one();
+      });
+
+      cv.wait(lock);
+    }
+  }
+
+  void RNSkOpenGLCanvasProvider::surfaceSizeChanged(int width, int height) {
+    if(width == 0 && height == 0) {
+      // Setting width/height to zero is nothing we need to care about when
+      // it comes to invalidating the surface.
+      return;
+    }
+    _width = width;
+    _height = height;
+
+    // Redraw after size change
+    _requestRedraw();
+  }
+}

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+#include <RNSkJsView.h>
+
+#include <SkiaOpenGLRenderer.h>
+#include <android/native_window.h>
+
+namespace RNSkia {
+
+class RNSkOpenGLCanvasProvider :
+        public RNSkia::RNSkCanvasProvider,
+        public std::enable_shared_from_this<RNSkOpenGLCanvasProvider> {
+public:
+    RNSkOpenGLCanvasProvider(std::function<void()> requestRedraw,
+                             std::shared_ptr <RNSkia::RNSkPlatformContext> context);
+
+    ~RNSkOpenGLCanvasProvider();
+
+    float getScaledWidth() override;
+
+    float getScaledHeight() override;
+
+    void renderToCanvas(const std::function<void(SkCanvas * )> &cb) override;
+
+    void surfaceAvailable(jobject surface, int width, int height);
+
+    void surfaceDestroyed();
+
+    void surfaceSizeChanged(int width, int height);
+
+private:
+    std::unique_ptr <SkiaOpenGLRenderer> _renderer = nullptr;
+    std::shared_ptr <RNSkPlatformContext> _context;
+    float _width = -1;
+    float _height = -1;
+};
+}