@shopify/react-native-skia 0.0.135

package/android/src/main/java/com/shopify/reactnative/skia/RNSkiaModule.java

@@ -0,0 +1,88 @@
+// RnskiaModule.java
+
+package com.shopify.reactnative.skia;
+
+import android.util.Log;
+
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+
+import java.lang.ref.WeakReference;
+
+@ReactModule(name="RNSkia")
+public class RNSkiaModule extends ReactContextBaseJavaModule implements LifecycleEventListener {
+    public static final String NAME = "RNSkia";
+
+    private final WeakReference<ReactApplicationContext> weakReactContext;
+    private SkiaManager skiaManager;
+
+    public RNSkiaModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.weakReactContext = new WeakReference<>(reactContext);
+        reactContext.addLifecycleEventListener(this);
+    }
+
+    @Override
+    public void invalidate() {
+        super.invalidate();
+
+        if (getReactApplicationContext() != null) {
+            getReactApplicationContext().removeLifecycleEventListener(this);
+        }
+
+        if (this.skiaManager != null) {
+            this.skiaManager.invalidate();
+            this.skiaManager.destroy();
+            this.skiaManager = null;
+        }
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    public SkiaManager getSkiaManager() {
+        return skiaManager;
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    public boolean install() {
+        if (skiaManager != null) {
+            // Already initialized, ignore call.
+            return true;
+        }
+
+        try {
+            System.loadLibrary("reactskia");
+            ReactApplicationContext context = weakReactContext.get();
+            if (context == null) {
+                Log.e(NAME, "React Application Context was null!");
+                return false;
+            }
+            skiaManager = new SkiaManager(context);
+            return true;
+        } catch (Exception exception) {
+            Log.e(NAME, "Failed to initialize Skia Manager!", exception);
+            return false;
+        }
+    }
+
+    @Override
+    public void onHostResume() {
+        if(skiaManager != null) skiaManager.onHostResume();
+    }
+
+    @Override
+    public void onHostPause() {
+        if(skiaManager != null) skiaManager.onHostPause();
+    }
+
+    @Override
+    public void onHostDestroy() {
+
+    }
+}

package/android/src/main/java/com/shopify/reactnative/skia/RNSkiaPackage.java

@@ -0,0 +1,24 @@
+// RnskiaPackage.java
+
+package com.shopify.reactnative.skia;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+public class RNSkiaPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(new RNSkiaModule(reactContext));
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Arrays.<ViewManager>asList(new RNSkiaViewManager());
+    }
+}

package/android/src/main/java/com/shopify/reactnative/skia/RNSkiaViewManager.java

@@ -0,0 +1,72 @@
+package com.shopify.reactnative.skia;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.LayoutShadowNode;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.util.HashMap;
+
+public class RNSkiaViewManager extends BaseViewManager<SkiaDrawView, LayoutShadowNode> {
+
+    final private HashMap<SkiaDrawView, Integer> mViewMapping = new HashMap();
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "ReactNativeSkiaView";
+    }
+
+    @Override
+    public LayoutShadowNode createShadowNodeInstance() {
+        return new LayoutShadowNode();
+    }
+
+    @Override
+    public Class<? extends LayoutShadowNode> getShadowNodeClass() {
+        return LayoutShadowNode.class;
+    }
+
+    @Override
+    public void updateExtraData(SkiaDrawView root, Object extraData) {
+    }
+
+    @Override
+    public void setNativeId(@NonNull SkiaDrawView view, @Nullable String nativeId) {
+        super.setNativeId(view, nativeId);
+        int nativeIdResolved = Integer.parseInt(nativeId);
+        RNSkiaModule skiaModule = ((ReactContext)view.getContext()).getNativeModule(RNSkiaModule.class);
+        skiaModule.getSkiaManager().register(nativeIdResolved, view);
+        mViewMapping.put(view, nativeIdResolved);
+    }
+
+    @ReactProp(name = "mode")
+    public void setMode(SkiaDrawView view, String mode) {
+        view.setMode(mode);
+    }
+
+    @ReactProp(name = "debug")
+    public void setDebug(SkiaDrawView view, boolean show) {
+        view.setDebugMode(show);
+    }
+
+    @Override
+    public void onDropViewInstance(@NonNull SkiaDrawView view) {
+        super.onDropViewInstance(view);
+        RNSkiaModule skiaModule = ((ReactContext)view.getContext()).getNativeModule(RNSkiaModule.class);
+        Integer nativeId = mViewMapping.get(view);
+        skiaModule.getSkiaManager().unregister(nativeId);
+        mViewMapping.remove(view);
+        view.onViewRemoved();
+    }
+
+    @NonNull
+    @Override
+    protected SkiaDrawView createViewInstance(@NonNull ThemedReactContext reactContext) {
+        return new SkiaDrawView(reactContext);
+    }
+}

package/android/src/main/java/com/shopify/reactnative/skia/SkiaDrawView.java

@@ -0,0 +1,131 @@
+package com.shopify.reactnative.skia;
+
+import android.content.Context;
+import android.graphics.SurfaceTexture;
+import android.util.Log;
+import android.view.Surface;
+import android.view.TextureView;
+import android.view.MotionEvent;
+
+import com.facebook.jni.HybridData;
+import com.facebook.jni.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactContext;
+
+public class SkiaDrawView extends TextureView implements TextureView.SurfaceTextureListener {
+
+    private static final String TAG = "Java::JniSkiaDrawView";
+
+    @DoNotStrip
+    private HybridData mHybridData;
+
+    @DoNotStrip
+    private boolean mViewRemoved;
+
+    @DoNotStrip
+    private Surface mSurface;
+
+    public SkiaDrawView(Context ctx) {
+        super(ctx);
+        RNSkiaModule skiaModule = ((ReactContext)ctx).getNativeModule(RNSkiaModule.class);
+        mHybridData = initHybrid(skiaModule.getSkiaManager());
+        setSurfaceTextureListener(this);
+        setOpaque(false);
+    }
+
+    @Override
+    public void setBackgroundColor(int color) {
+        // Texture view does not support setting the background color.
+    }
+
+    public void releaseSurface() {
+        if(mSurface != null) {
+            mSurface.release();
+            mSurface = null;
+        }
+        // We can only reset the native side when the view was removed from screen.
+        // releasing the surface can also be done when the view is hidden and then
+        // we should only release the surface - and keep the native part around.
+        if(mViewRemoved) {
+            mHybridData.resetNative();
+        }
+    }
+
+    void onViewRemoved() {
+        mViewRemoved = true;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        int action = ev.getAction();
+        int count = ev.getPointerCount();
+        MotionEvent.PointerCoords r = new MotionEvent.PointerCoords();
+        double[] points = new double[count*5];
+        for (int i = 0; i < count; i++) {
+            ev.getPointerCoords(i, r);
+            points[i] = r.x;
+            points[i+1] = r.y;
+            points[i+2] = ev.getPressure(i);
+            switch (action) {
+                case MotionEvent.ACTION_DOWN:
+                case MotionEvent.ACTION_POINTER_DOWN:
+                    points[i+3] = 0;
+                    break;
+                case MotionEvent.ACTION_MOVE:
+                    points[i+3] = 1;
+                    break;
+                case MotionEvent.ACTION_UP:
+                case MotionEvent.ACTION_POINTER_UP:
+                    points[i+3] = 2;
+                    break;
+                case MotionEvent.ACTION_CANCEL:
+                    points[i+3] = 3;
+                    break;
+            }
+            points[i+4] = ev.getPointerId(i);
+        }
+        updateTouchPoints(points);
+        return true;
+    }
+
+    @Override
+    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
+        mSurface = new Surface(surface);
+        surfaceAvailable(mSurface, width, height);
+    }
+
+    @Override
+    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
+        surfaceSizeChanged(width, height);
+    }
+
+    @Override
+    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+        surfaceDestroyed();
+        // https://developer.android.com/reference/android/view/TextureView.SurfaceTextureListener#onSurfaceTextureDestroyed(android.graphics.SurfaceTexture)
+        // Invoked when the specified SurfaceTexture is about to be destroyed. If returns true,
+        // no rendering should happen inside the surface texture after this method is invoked.
+        // If returns false, the client needs to call SurfaceTexture#release().
+        return false;
+    }
+
+    @Override
+    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
+        // Nothing special to do here
+    }
+
+    private native HybridData initHybrid(SkiaManager skiaManager);
+
+    private native void surfaceAvailable(Object surface, int width, int height);
+
+    private native void surfaceSizeChanged(int width, int height);
+
+    private native void surfaceDestroyed();
+
+    private native void setBgColor(int color);
+
+    public native void setMode(String mode);
+
+    public native void setDebugMode(boolean show);
+
+    public native void updateTouchPoints(double[] points);
+}

package/android/src/main/java/com/shopify/reactnative/skia/SkiaManager.java

@@ -0,0 +1,66 @@
+package com.shopify.reactnative.skia;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+
+@DoNotStrip
+public class SkiaManager {
+
+    @DoNotStrip
+    private HybridData mHybridData;
+
+    @DoNotStrip
+    private ReactContext mContext;
+
+    @DoNotStrip
+    private PlatformContext mPlatformContext;
+
+    @DoNotStrip
+    SkiaManager(ReactContext context) {
+        super();
+        mContext = context;
+
+        CallInvokerHolderImpl holder = (CallInvokerHolderImpl) context.getCatalystInstance().getJSCallInvokerHolder();
+
+        mPlatformContext = new PlatformContext(context);
+
+        mHybridData = initHybrid(context.getJavaScriptContextHolder().get(), holder, mPlatformContext);
+
+        initializeRuntime();
+    }
+
+    public void destroy() {
+        mHybridData.resetNative();
+    }
+
+    public float getPixelDensity() {
+        return mContext.getResources().getDisplayMetrics().density;
+    }
+
+    public PlatformContext getPlatformContext() {
+        return mPlatformContext;
+    }
+
+    public void register(int nativeId, SkiaDrawView view) {
+        registerSkiaView(nativeId, view);
+    }
+
+    public void unregister(int nativeId) {
+        unregisterSkiaView(nativeId);
+    }
+
+    public void onHostResume() { mPlatformContext.onResume(); }
+
+    public void onHostPause() {  mPlatformContext.onPause(); }
+
+    // private C++ functions
+    private native HybridData initHybrid(long jsContext, CallInvokerHolderImpl jsCallInvokerHolder,
+            PlatformContext platformContext);
+    private native void initializeRuntime();
+    private native void registerSkiaView(int nativeId, SkiaDrawView view);
+    private native void unregisterSkiaView(int nativeId);
+    public native void invalidate();
+
+}

package/cpp/api/JsiSkApi.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include "RNSkPlatformContext.h"
+
+#include "JsiSkHostObjects.h"
+
+#include "JsiSkRuntimeEffect.h"
+#include "JsiSkColorFilter.h"
+#include "JsiSkColorFilterFactory.h"
+#include "JsiSkFont.h"
+#include "JsiSkImage.h"
+#include "JsiSkImageFactory.h"
+#include "JsiSkImageFilter.h"
+#include "JsiSkImageFilterFactory.h"
+#include "JsiSkMaskFilter.h"
+#include "JsiSkMaskFilterFactory.h"
+#include "JsiSkMatrix.h"
+#include "JsiSkPaint.h"
+#include "JsiSkRSXform.h"
+#include "JsiSkPath.h"
+#include "JsiSkPathEffect.h"
+#include "JsiSkPathEffectFactory.h"
+#include "JsiSkPathFactory.h"
+#include "JsiSkPoint.h"
+#include "JsiSkRRect.h"
+#include "JsiSkRect.h"
+#include "JsiSkRuntimeEffectFactory.h"
+#include "JsiSkShader.h"
+#include "JsiSkShaderFactory.h"
+#include "JsiSkSVG.h"
+#include "JsiSkSVGFactory.h"
+#include "JsiSkTypeface.h"
+#include "JsiSkVertices.h"
+#include "JsiSkTypefaceFactory.h"
+#include "JsiSkDataFactory.h"
+#include "JsiSkFontMgrFactory.h"
+#include "JsiSkSurfaceFactory.h"
+#include "JsiSkTextBlobFactory.h"
+#include "JsiSkContourMeasureIter.h"
+#include "JsiSkPictureRecorder.h"
+#include "JsiSkPictureFactory.h"
+#include "JsiSkRuntimeShaderBuilder.h"
+#include "JsiSkColor.h"
+
+namespace RNSkia
+{
+
+  using namespace facebook;
+
+  class JsiSkApi : public JsiSkHostObject
+  {
+  public:
+    /**
+   * Constructs the Skia Api object that can be installed into a runtime
+   * and provide functions for accessing and creating the Skia wrapper objects
+   * @param context Platform context
+   */
+    JsiSkApi(jsi::Runtime &runtime, std::shared_ptr<RNSkPlatformContext> context)
+        : JsiSkHostObject(context)
+    {
+
+      installFunction("Font", JsiSkFont::createCtor(context));
+      installFunction("Paint", JsiSkPaint::createCtor(context));
+      installFunction("RSXform", JsiSkRSXform::createCtor(context));
+      installFunction("Matrix", JsiSkMatrix::createCtor(context));
+      installFunction("XYWHRect", JsiSkRect::createCtor(context));
+      installFunction("RRectXY", JsiSkRRect::createCtor(context));
+      installFunction("Point", JsiSkPoint::createCtor(context));
+      installFunction("RuntimeShaderBuilder", JsiSkRuntimeShaderBuilder::createCtor(context));
+      installFunction("ContourMeasureIter", JsiSkContourMeasureIter::createCtor(context));
+      installFunction("MakeVertices", JsiSkVertices::createCtor(context));
+      installFunction("PictureRecorder", JsiSkPictureRecorder::createCtor(context));
+      installFunction("Color", JsiSkColor::createCtor());
+
+      // Static members
+      installReadonlyProperty("FontMgr",
+                              std::make_shared<JsiSkFontMgrFactory>(context));
+      installReadonlyProperty("SVG",
+                              std::make_shared<JsiSkSVGFactory>(context));
+      installReadonlyProperty("Image",
+                              std::make_shared<JsiSkImageFactory>(context));
+      installReadonlyProperty("Typeface",
+                              std::make_shared<JsiSkTypefaceFactory>(context));
+      installReadonlyProperty("Data",
+                              std::make_shared<JsiSkDataFactory>(context));
+      installReadonlyProperty("ImageFilter",
+                              std::make_shared<JsiSkImageFilterFactory>(context));
+      installReadonlyProperty("PathEffect",
+                              std::make_shared<JsiSkPathEffectFactory>(context));
+      installReadonlyProperty("Path",
+                              std::make_shared<JsiSkPathFactory>(context));
+      installReadonlyProperty("ColorFilter",
+                              std::make_shared<JsiSkColorFilterFactory>(context));
+      installReadonlyProperty("MaskFilter",
+                              std::make_shared<JsiSkMaskFilterFactory>(context));
+      installReadonlyProperty(
+          "RuntimeEffect", std::make_shared<JsiSkRuntimeEffectFactory>(context));
+      installReadonlyProperty("Shader",
+                              std::make_shared<JsiSkShaderFactory>(context));
+      installReadonlyProperty("TextBlob", std::make_shared<JsiSkTextBlobFactory>(context));
+      installReadonlyProperty("Surface", std::make_shared<JsiSkSurfaceFactory>(context));
+      installReadonlyProperty("Picture", std::make_shared<JsiSkPictureFactory>(context));
+    };
+  };
+} // namespace RNSkia