@shopify/react-native-skia 0.1.115

package/android/cpp/jni/JniSkiaManager.cpp

@@ -0,0 +1,57 @@
+#include "JniSkiaManager.h"
+
+#include <android/log.h>
+#include <jni.h>
+#include <string>
+#include <utility>
+
+#include "JniSkiaDrawView.h"
+#include <RNSkManager.h>
+
+namespace RNSkia {
+
+using namespace facebook;
+
+// JNI binding
+void JniSkiaManager::registerNatives() {
+    registerHybrid({
+        makeNativeMethod("initHybrid", JniSkiaManager::initHybrid),
+        makeNativeMethod(
+            "initializeRuntime", JniSkiaManager::initializeRuntime),
+        makeNativeMethod("registerSkiaView", JniSkiaManager::registerSkiaView),
+        makeNativeMethod(
+            "unregisterSkiaView", JniSkiaManager::unregisterSkiaView),
+        makeNativeMethod(
+            "invalidate", JniSkiaManager::invalidate),
+    });
+}
+
+// JNI init
+jni::local_ref<jni::HybridClass<JniSkiaManager>::jhybriddata> JniSkiaManager::initHybrid(
+    jni::alias_ref<jhybridobject> jThis,
+    jlong jsContext,
+    JSCallInvokerHolder jsCallInvokerHolder,
+    JavaPlatformContext skiaContext) {
+
+    // cast from JNI hybrid objects to C++ instances
+    return makeCxxInstance(
+        jThis,
+        reinterpret_cast<jsi::Runtime *>(jsContext),
+        jsCallInvokerHolder->cthis()->getCallInvoker(),
+        skiaContext->cthis());
+}
+
+void JniSkiaManager::initializeRuntime() {
+    // Create the cross platform skia manager
+    _skManager = std::make_shared<RNSkManager>(_jsRuntime, _jsCallInvoker, _context);
+}
+
+void JniSkiaManager::registerSkiaView(int viewTag, JniSkiaDrawView *skiaView) {
+    _skManager->registerSkiaDrawView(viewTag, skiaView);
+}
+
+void JniSkiaManager::unregisterSkiaView(int viewTag) {
+    _skManager->unregisterSkiaDrawView(viewTag);
+}
+
+} // namespace RNSkia

package/android/cpp/jni/SkiaOpenGLRenderer.cpp

@@ -0,0 +1,340 @@
+#include "SkiaOpenGLRenderer.h"
+
+#include <RNSkLog.h>
+namespace RNSkia
+{
+
+    /** Static members */
+    std::shared_ptr<DrawingContext> SkiaOpenGLRenderer::getThreadDrawingContext()
+    {
+        auto threadId = std::this_thread::get_id();
+        if (threadContexts.count(threadId) == 0)
+        {
+            auto drawingContext = std::make_shared<DrawingContext>();
+            drawingContext->glContext = EGL_NO_CONTEXT;
+            drawingContext->glDisplay = EGL_NO_DISPLAY;
+            drawingContext->glConfig = 0;
+            drawingContext->skContext = nullptr;
+            threadContexts.emplace(threadId, drawingContext);
+        }
+        return threadContexts.at(threadId);
+    }
+
+    void SkiaOpenGLRenderer::run(const sk_sp<SkPicture> picture, int width, int height)
+    {
+        switch (_renderState)
+        {
+        case RenderState::Initializing:
+        {
+            _renderState = RenderState::Rendering;
+            // Just let the case drop to drawing - we have initialized
+            // and we should be able to render (if the picture is set)
+        }
+        case RenderState::Rendering:
+        {
+            // Make sure to initialize the rendering pipeline
+            if (!ensureInitialised())
+            {
+                break;
+            }
+
+            // Ensure we have the Skia surface to draw on. We need to
+            // pass width and height since the surface will be recreated
+            // when the view is resized.
+            if (!ensureSkiaSurface(width, height))
+            {
+                return;
+            }
+
+            if (picture != nullptr)
+            {
+                // Reset Skia Context since it might be modified by another Skia View during
+                // rendering.
+                getThreadDrawingContext()->skContext->resetContext();
+
+                // Clear with transparent
+                glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+                glClear(GL_COLOR_BUFFER_BIT);
+
+                // Draw picture into surface
+                _skSurface->getCanvas()->drawPicture(picture);
+
+                // Flush
+                _skSurface->getCanvas()->flush();
+                getThreadDrawingContext()->skContext->flush();
+
+                if (!eglSwapBuffers(getThreadDrawingContext()->glDisplay, _glSurface))
+                {
+                    RNSkLogger::logToConsole(
+                        "eglSwapBuffers failed: %d\n", eglGetError());
+                }
+            }
+            break;
+        }
+        case RenderState::Finishing:
+        {
+            finish();
+            break;
+        }
+        case RenderState::Done:
+        {
+            // Do nothing. We're done.
+            break;
+        }
+        }
+    }
+
+    bool SkiaOpenGLRenderer::ensureInitialised()
+    {
+        // Set up static OpenGL context
+        if (!initStaticGLContext())
+        {
+            return false;
+        }
+
+        // Set up OpenGL Surface
+        if (!initGLSurface())
+        {
+            return false;
+        }
+
+        // Init skia static context
+        if (!initStaticSkiaContext())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    void SkiaOpenGLRenderer::finish()
+    {
+        std::lock_guard<std::mutex> lock(_lock);
+
+        if (_renderState != RenderState::Finishing)
+        {
+            _cv.notify_all();
+            return;
+        }
+
+        finishGL();
+        finishSkiaSurface();
+
+        _renderState = RenderState::Done;
+
+        _cv.notify_one();
+    }
+
+    void SkiaOpenGLRenderer::finishGL()
+    {
+        if (_glSurface != EGL_NO_SURFACE && getThreadDrawingContext()->glDisplay != EGL_NO_DISPLAY)
+        {
+            eglDestroySurface(getThreadDrawingContext()->glDisplay, _glSurface);
+        }
+    }
+
+    void SkiaOpenGLRenderer::finishSkiaSurface()
+    {
+        if (_skSurface != nullptr)
+        {
+            _skSurface = nullptr;
+        }
+
+        if (_nativeWindow != nullptr)
+        {
+            ANativeWindow_release(_nativeWindow);
+            _nativeWindow = nullptr;
+        }
+    }
+
+    void SkiaOpenGLRenderer::teardown()
+    {
+        _renderState = RenderState::Finishing;
+    }
+
+    void SkiaOpenGLRenderer::waitForTeardown()
+    {
+        std::unique_lock<std::mutex> lock(_lock);
+        _cv.wait(lock, [this]
+                 { return (_renderState == RenderState::Done); });
+    }
+
+    bool SkiaOpenGLRenderer::initStaticGLContext()
+    {
+        if (getThreadDrawingContext()->glContext != EGL_NO_CONTEXT)
+        {
+            return true;
+        }
+
+        getThreadDrawingContext()->glDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+        if (getThreadDrawingContext()->glDisplay == EGL_NO_DISPLAY)
+        {
+            RNSkLogger::logToConsole("eglGetdisplay failed : %i", glGetError());
+            return false;
+        }
+
+        EGLint major;
+        EGLint minor;
+        if (!eglInitialize(getThreadDrawingContext()->glDisplay, &major, &minor))
+        {
+            RNSkLogger::logToConsole("eglInitialize failed : %i", glGetError());
+            return false;
+        }
+
+        EGLint att[] = {
+            EGL_RENDERABLE_TYPE,
+            EGL_OPENGL_ES2_BIT,
+            EGL_SURFACE_TYPE,
+            EGL_WINDOW_BIT,
+            EGL_ALPHA_SIZE,
+            8,
+            EGL_BLUE_SIZE,
+            8,
+            EGL_GREEN_SIZE,
+            8,
+            EGL_RED_SIZE,
+            8,
+            EGL_DEPTH_SIZE,
+            0,
+            EGL_STENCIL_SIZE,
+            0,
+            EGL_NONE};
+
+        EGLint numConfigs;
+        getThreadDrawingContext()->glConfig = 0;
+        if (!eglChooseConfig(getThreadDrawingContext()->glDisplay, att, &getThreadDrawingContext()->glConfig, 1, &numConfigs) ||
+            numConfigs == 0)
+        {
+            RNSkLogger::logToConsole(
+                "Failed to choose a config %d\n", eglGetError());
+            return false;
+        }
+
+        EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
+
+        getThreadDrawingContext()->glContext = eglCreateContext(getThreadDrawingContext()->glDisplay, getThreadDrawingContext()->glConfig, NULL, contextAttribs);
+        if (getThreadDrawingContext()->glContext == EGL_NO_CONTEXT)
+        {
+            RNSkLogger::logToConsole(
+                "eglCreateContext failed: %d\n", eglGetError());
+            return false;
+        }
+
+        return true;
+    }
+
+    bool SkiaOpenGLRenderer::initStaticSkiaContext()
+    {
+        if (getThreadDrawingContext()->skContext != nullptr)
+        {
+            return true;
+        }
+
+        // Create the Skia backend context
+        auto backendInterface = GrGLMakeNativeInterface();
+        getThreadDrawingContext()->skContext = GrDirectContext::MakeGL(backendInterface);
+        if (getThreadDrawingContext()->skContext == nullptr)
+        {
+            RNSkLogger::logToConsole("GrDirectContext::MakeGL failed");
+            return false;
+        }
+
+        return true;
+    }
+
+    bool SkiaOpenGLRenderer::initGLSurface()
+    {
+        if (_nativeWindow == nullptr)
+        {
+            return false;
+        }
+
+        if (_glSurface != EGL_NO_SURFACE)
+        {
+            if (!eglMakeCurrent(getThreadDrawingContext()->glDisplay, _glSurface, _glSurface, getThreadDrawingContext()->glContext))
+            {
+                RNSkLogger::logToConsole(
+                    "eglMakeCurrent failed: %d\n", eglGetError());
+                return false;
+            }
+            return true;
+        }
+
+        // Create the opengl surface
+        _glSurface =
+            eglCreateWindowSurface(getThreadDrawingContext()->glDisplay, getThreadDrawingContext()->glConfig, _nativeWindow, nullptr);
+        if (_glSurface == EGL_NO_SURFACE)
+        {
+            RNSkLogger::logToConsole(
+                "eglCreateWindowSurface failed: %d\n", eglGetError());
+            return false;
+        }
+
+        if (!eglMakeCurrent(getThreadDrawingContext()->glDisplay, _glSurface, _glSurface, getThreadDrawingContext()->glContext))
+        {
+            RNSkLogger::logToConsole("eglMakeCurrent failed: %d\n", eglGetError());
+            return false;
+        }
+
+        return true;
+    }
+
+    bool SkiaOpenGLRenderer::ensureSkiaSurface(int width, int height)
+    {
+        if (getThreadDrawingContext()->skContext == nullptr)
+        {
+            return false;
+        }
+
+        if (_skSurface == nullptr ||
+            !_skRenderTarget.isValid() ||
+            _prevWidth != width ||
+            _prevHeight != height)
+        {
+            glViewport(0, 0, width, height);
+
+            _prevWidth = width;
+            _prevHeight = height;
+
+            GLint buffer;
+            glGetIntegerv(GL_FRAMEBUFFER_BINDING, &buffer);
+
+            GLint stencil;
+            glGetIntegerv(GL_STENCIL_BITS, &stencil);
+
+            GLint samples;
+            glGetIntegerv(GL_SAMPLES, &samples);
+
+            auto maxSamples = getThreadDrawingContext()->skContext->maxSurfaceSampleCountForColorType(
+                kRGBA_8888_SkColorType);
+
+            if (samples > maxSamples)
+                samples = maxSamples;
+
+            GrGLFramebufferInfo fbInfo;
+            fbInfo.fFBOID = buffer;
+            fbInfo.fFormat = 0x8058;
+
+            _skRenderTarget =
+                GrBackendRenderTarget(width, height, samples, stencil, fbInfo);
+
+            _skSurface = SkSurface::MakeFromBackendRenderTarget(
+                getThreadDrawingContext()->skContext.get(),
+                _skRenderTarget,
+                kBottomLeft_GrSurfaceOrigin,
+                kRGBA_8888_SkColorType,
+                nullptr,
+                nullptr);
+
+            if (!_skSurface)
+            {
+                RNSkLogger::logToConsole(
+                    "JniSkiaDrawView::setupSurface - skSurface could not be created!");
+                return false;
+            }
+
+            return true;
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <ReactCommon/CallInvokerHolder.h>
+
+#include <queue>
+#include <mutex>
+#include <functional>
+#include <memory>
+#include <string>
+#include <exception>
+
+#include "RNSkPlatformContext.h"
+
+class SkStreamAsset;
+namespace RNSkia
+{
+
+    using namespace facebook;
+
+    using JSCallInvokerHolder =
+        jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>;
+
+    class JniPlatformContext : public jni::HybridClass<JniPlatformContext>
+    {
+    public:
+        static auto constexpr kJavaDescriptor = "Lcom/shopify/reactnative/skia/PlatformContext;";
+
+        static jni::local_ref<jhybriddata> initHybrid(
+            jni::alias_ref<jhybridobject> jThis,
+            const float);
+
+        static void registerNatives();
+
+        void performStreamOperation(
+            const std::string &sourceUri,
+            const std::function<void(std::unique_ptr<SkStreamAsset>)> &op);
+
+        void raiseError(const std::exception &err);
+
+        void startDrawLoop();
+        void stopDrawLoop();
+
+        void notifyDrawLoopExternal();
+
+        void notifyTaskReadyExternal();
+
+        float getPixelDensity() { return _pixelDensity; }
+
+        void setOnNotifyDrawLoop(const std::function<void(void)>& callback) {
+            _onNotifyDrawLoop = callback;
+        }
+
+    private:
+        friend HybridBase;
+        jni::global_ref<JniPlatformContext::javaobject> javaPart_;
+
+        float _pixelDensity;
+
+        std::function<void(void)> _onNotifyDrawLoop;
+
+        std::queue<std::function<void()>> _taskCallbacks;
+
+        std::shared_ptr<std::mutex> _taskMutex;
+
+        explicit JniPlatformContext(
+            jni::alias_ref<JniPlatformContext::jhybridobject> jThis,
+            const float pixelDensity)
+            : _taskMutex(std::make_shared<std::mutex>()),
+              javaPart_(jni::make_global(jThis)),
+              _pixelDensity(pixelDensity)
+        {
+        }
+    };
+} // namespace RNSkia

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

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <memory>
+#include <exception>
+
+#include <JniPlatformContext.h>
+#include <RNSkPlatformContext.h>
+
+namespace RNSkia {
+    using namespace facebook;
+
+    class JniPlatformContextWrapper: public RNSkPlatformContext {
+    public:
+        JniPlatformContextWrapper(JniPlatformContext* jniPlatformContext,
+                                  jsi::Runtime *runtime,
+                                  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker) :
+            RNSkPlatformContext(runtime,
+                                jsCallInvoker,
+                                jniPlatformContext->getPixelDensity()),
+            _jniPlatformContext(jniPlatformContext) {
+            // Hook onto the notify draw loop callback in the platform context
+            jniPlatformContext->setOnNotifyDrawLoop([this]() {
+                notifyDrawLoop(false);
+            });
+        }
+
+
+    void performStreamOperation(
+            const std::string &sourceUri,
+            const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override {
+        _jniPlatformContext->performStreamOperation(sourceUri, op);
+    }
+
+    void raiseError(const std::exception &err) override {
+        _jniPlatformContext->raiseError(err);
+    }
+
+    void startDrawLoop() override {
+        _jniPlatformContext->startDrawLoop();
+    }
+
+    void stopDrawLoop() override {
+        _jniPlatformContext->stopDrawLoop();
+    }
+
+    private:
+
+        JniPlatformContext* _jniPlatformContext;
+    };
+
+}
+

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

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <map>
+#include <memory>
+#include <thread>
+#include <string>
+
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <thread>
+
+#include <RNSkDrawView.h>
+#include "JniSkiaManager.h"
+#include "JniSkiaDrawView.h"
+#include "SkiaOpenGLRenderer.h"
+
+#include <SkSurface.h>
+#include <SkRefCnt.h>
+#include <gpu/GrBackendSurface.h>
+#include <gpu/GrDirectContext.h>
+
+class SkPicture;
+class ANativeWindow;
+
+namespace RNSkia
+{
+    using namespace facebook;
+
+    using JavaSkiaManager = jni::alias_ref<JniSkiaManager::javaobject>;
+
+    class JniSkiaDrawView : public jni::HybridClass<JniSkiaDrawView>,
+                            public RNSkDrawView
+    {
+    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 void registerNatives();
+
+        void surfaceAvailable(jobject, int, int);
+        void surfaceDestroyed();
+        void surfaceSizeChanged(int, int);
+
+        void updateTouchPoints(jni::JArrayDouble touches);
+
+        ~JniSkiaDrawView();
+
+    protected:
+        int getWidth() override { return _width; }
+        int getHeight() override { return _height; }
+
+        void setMode(std::string mode);
+        void setDebugMode(bool show);
+
+    private:
+        friend HybridBase;
+
+        void drawFrame(const sk_sp<SkPicture> picture);
+
+        int _width = 0;
+        int _height = 0;
+
+        SkiaOpenGLRenderer* _renderer = nullptr;
+
+        jni::global_ref<JniSkiaDrawView::javaobject> javaPart_;
+
+        explicit JniSkiaDrawView(
+            jni::alias_ref<JniSkiaDrawView::jhybridobject> jThis,
+            JavaSkiaManager skiaManager)
+            : javaPart_(jni::make_global(jThis)),
+              RNSkDrawView(skiaManager->cthis()->getPlatformContext()) {
+        }
+    };
+
+} // namespace RNSkia

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

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <memory>
+
+#include <JniPlatformContext.h>
+#include <JniPlatformContextWrapper.h>
+
+#include <RNSkLog.h>
+
+namespace RNSkia {
+class RNSkManager;
+using namespace facebook;
+
+using JSCallInvokerHolder =
+    jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>;
+
+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;";
+    static auto constexpr TAG = "ReactNativeSkia";
+
+    static jni::local_ref<jni::HybridClass<JniSkiaManager>::jhybriddata> initHybrid(
+        jni::alias_ref<jhybridobject> jThis,
+        jlong jsContext,
+        JSCallInvokerHolder jsCallInvokerHolder,
+        JavaPlatformContext platformContext);
+
+    static void registerNatives();
+
+    JniSkiaManager() {}
+    ~JniSkiaManager() {
+        RNSkLogger::logToConsole("JniSkiaManager dtor");
+    }
+
+    explicit JniSkiaManager(
+        jni::alias_ref<JniSkiaManager::jhybridobject> jThis,
+        jsi::Runtime *runtime,
+        std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
+        JniPlatformContext* platformContext)
+        : _javaPart(jni::make_global(jThis)),
+          _jsRuntime(runtime),
+          _jsCallInvoker(jsCallInvoker),
+          _context(std::make_shared<JniPlatformContextWrapper>(platformContext, runtime, jsCallInvoker)) {
+
+    }
+
+    void registerSkiaView(int viewTag, JniSkiaDrawView *skiaView);
+    void unregisterSkiaView(int viewTag);
+
+    std::shared_ptr<JniPlatformContextWrapper> getPlatformContext() { return _context; }
+
+    void invalidate() {
+        _context->stopDrawLoop();
+        _context->notifyDrawLoop(true);
+        _skManager = nullptr;
+        _context = nullptr;
+    }
+
+   private:
+    friend HybridBase;
+
+    std::shared_ptr<RNSkManager> _skManager;
+
+    jni::global_ref<JniSkiaManager::javaobject> _javaPart;
+
+    jsi::Runtime *_jsRuntime;
+    std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;
+    std::shared_ptr<JniPlatformContextWrapper> _context;
+
+    void initializeRuntime();
+};
+
+} // namespace RNSkia