react-native-skia 3.0.0 → 3.0.2

package/android/cpp/rnskia-android/{RNSkOpenGLCanvasProvider.cpp → RNSkAndroidCanvasProvider.cpp}

@@ -1,55 +1,40 @@
-#include "RNSkOpenGLCanvasProvider.h"
+#include "RNSkAndroidCanvasProvider.h"
 
 #include <android/native_window_jni.h>
 #include <fbjni/fbjni.h>
 #include <jni.h>
 #include <memory>
 
-#include "RNSkLog.h"
-
-#if defined(SK_GRAPHITE)
 #include "RNDawnContext.h"
-#else
-#include "OpenGLContext.h"
-#endif
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkCanvas.h"
-#include "include/core/SkSurface.h"
-
-#pragma clang diagnostic pop
+#include "RNSkLog.h"
 
 namespace RNSkia {
 
-RNSkOpenGLCanvasProvider::RNSkOpenGLCanvasProvider(
-    std::function<void()> requestRedraw,
-    std::shared_ptr<RNSkia::RNSkPlatformContext> platformContext)
-    : RNSkCanvasProvider(std::move(requestRedraw)),
-      _platformContext(std::move(platformContext)) {}
+RNSkAndroidCanvasProvider::RNSkAndroidCanvasProvider(
+    std::shared_ptr<RNSkPlatformContext> platformContext)
+    : _platformContext(std::move(platformContext)) {}
 
-RNSkOpenGLCanvasProvider::~RNSkOpenGLCanvasProvider() {
+RNSkAndroidCanvasProvider::~RNSkAndroidCanvasProvider() {
   _surfaceHolder = nullptr;
   releaseWindow();
 }
 
-int RNSkOpenGLCanvasProvider::getWidth() {
+int RNSkAndroidCanvasProvider::getWidth() {
   if (_surfaceHolder) {
     return _surfaceHolder->getWidth();
   }
   return 0;
 }
 
-int RNSkOpenGLCanvasProvider::getHeight() {
+int RNSkAndroidCanvasProvider::getHeight() {
   if (_surfaceHolder) {
     return _surfaceHolder->getHeight();
   }
   return 0;
 }
 
-ANativeWindow *RNSkOpenGLCanvasProvider::acquireWindow(jobject surface,
-                                                       bool isSurface) {
+ANativeWindow *RNSkAndroidCanvasProvider::acquireWindow(jobject surface,
+                                                        bool isSurface) {
   JNIEnv *env = facebook::jni::Environment::current();
   jobject jSurface = surface;
   if (!isSurface) {
@@ -65,20 +50,13 @@ ANativeWindow *RNSkOpenGLCanvasProvider::acquireWindow(jobject surface,
     env->DeleteLocalRef(localSurface);
     env->DeleteLocalRef(surfaceClass);
     jSurface = _jSurface;
-#if !defined(SK_GRAPHITE)
-    _jSurfaceTexture = env->NewGlobalRef(surface);
-    jclass surfaceTextureClass = env->GetObjectClass(surface);
-    _updateTexImageMethod =
-        env->GetMethodID(surfaceTextureClass, "updateTexImage", "()V");
-    env->DeleteLocalRef(surfaceTextureClass);
-#endif
   }
   // Acquires a reference on the window, given back by releaseWindow().
   _window = ANativeWindow_fromSurface(env, jSurface);
   return _window;
 }
 
-void RNSkOpenGLCanvasProvider::releaseWindow() {
+void RNSkAndroidCanvasProvider::releaseWindow() {
   if (_window == nullptr && _jSurface == nullptr) {
     return;
   }
@@ -97,33 +75,9 @@ void RNSkOpenGLCanvasProvider::releaseWindow() {
     env->DeleteGlobalRef(_jSurface);
     _jSurface = nullptr;
   }
-#if !defined(SK_GRAPHITE)
-  if (_jSurfaceTexture != nullptr) {
-    env->DeleteGlobalRef(_jSurfaceTexture);
-    _jSurfaceTexture = nullptr;
-    _updateTexImageMethod = nullptr;
-  }
-#endif
-}
-
-#if !defined(SK_GRAPHITE)
-void RNSkOpenGLCanvasProvider::updateTexImage() {
-  if (_jSurfaceTexture) {
-    JNIEnv *env = facebook::jni::Environment::current();
-    env->CallVoidMethod(_jSurfaceTexture, _updateTexImageMethod);
-
-    // Check for exceptions
-    if (env->ExceptionCheck()) {
-      RNSkLogger::logToConsole("updateAndRelease() failed. The exception above "
-                               "can safely be ignored");
-      env->ExceptionClear();
-    }
-  }
 }
-#endif
 
-#if defined(SK_GRAPHITE)
-void RNSkOpenGLCanvasProvider::updateTargetInfo() {
+void RNSkAndroidCanvasProvider::updateTargetInfo() {
   std::lock_guard<std::mutex> lock(_targetInfoMutex);
   if (_surfaceHolder == nullptr) {
     _hasTargetInfo = false;
@@ -137,8 +91,7 @@ void RNSkOpenGLCanvasProvider::updateTargetInfo() {
   _hasTargetInfo = true;
 }
 
-bool RNSkOpenGLCanvasProvider::getGraphiteTargetInfo(
-    RNSkGraphiteTargetInfo *info) {
+bool RNSkAndroidCanvasProvider::getTargetInfo(RNSkGraphiteTargetInfo *info) {
   std::lock_guard<std::mutex> lock(_targetInfoMutex);
   if (!_hasTargetInfo) {
     return false;
@@ -147,7 +100,23 @@ bool RNSkOpenGLCanvasProvider::getGraphiteTargetInfo(
   return true;
 }
 
-bool RNSkOpenGLCanvasProvider::presentRecordings(
+void RNSkAndroidCanvasProvider::setLayoutSize(int width, int height) {
+  std::lock_guard<std::mutex> lock(_targetInfoMutex);
+  _layoutWidth = width;
+  _layoutHeight = height;
+}
+
+bool RNSkAndroidCanvasProvider::getLayoutSize(int *width, int *height) {
+  std::lock_guard<std::mutex> lock(_targetInfoMutex);
+  if (_layoutWidth <= 0 || _layoutHeight <= 0) {
+    return false;
+  }
+  *width = _layoutWidth;
+  *height = _layoutHeight;
+  return true;
+}
+
+bool RNSkAndroidCanvasProvider::presentRecordings(
     const std::vector<skgpu::graphite::Recording *> &recordings) {
   if (_surfaceHolder == nullptr) {
     return false;
@@ -155,33 +124,18 @@ bool RNSkOpenGLCanvasProvider::presentRecordings(
   return static_cast<DawnWindowContext *>(_surfaceHolder.get())
       ->presentRecordings(recordings);
 }
-#endif
-
-bool RNSkOpenGLCanvasProvider::renderToCanvas(
-    const std::function<void(SkCanvas *)> &cb) {
-  if (_surfaceHolder != nullptr && cb != nullptr) {
-    // Get the surface
-    auto surface = _surfaceHolder->getSurface();
-#if !defined(SK_GRAPHITE)
-    updateTexImage();
-#endif
-    if (surface) {
-      // Draw into canvas using callback
-      cb(surface->getCanvas());
-      // Swap buffers and show on screen
-      _surfaceHolder->present();
-      return true;
-    } else {
-      // the render context did not provide a surface
-      return false;
-    }
+
+bool RNSkAndroidCanvasProvider::presentImage(const sk_sp<SkImage> &image) {
+  if (_surfaceHolder == nullptr) {
+    return false;
   }
-  return false;
+  return static_cast<DawnWindowContext *>(_surfaceHolder.get())
+      ->presentImage(image);
 }
 
-void RNSkOpenGLCanvasProvider::surfaceAvailable(jobject surface, int width,
-                                                int height, bool isSurface,
-                                                bool highBitDepth) {
+void RNSkAndroidCanvasProvider::surfaceAvailable(jobject surface, int width,
+                                                 int height, bool isSurface,
+                                                 bool highBitDepth) {
   // Release the old surface and its window
   _surfaceHolder = nullptr;
   releaseWindow();
@@ -192,32 +146,25 @@ void RNSkOpenGLCanvasProvider::surfaceAvailable(jobject surface, int width,
     releaseWindow();
     return;
   }
-#if defined(SK_GRAPHITE)
   _surfaceHolder = DawnContext::getInstance().MakeWindow(window, width, height,
                                                          highBitDepth);
   updateTargetInfo();
-#else
-  _surfaceHolder =
-      OpenGLContext::getInstance().MakeWindow(window, highBitDepth);
-#endif
 
   // Post redraw request to ensure we paint in the next draw cycle.
-  _requestRedraw();
+  requestRedraw();
 }
 
-void RNSkOpenGLCanvasProvider::surfaceDestroyed() {
+void RNSkAndroidCanvasProvider::surfaceDestroyed() {
   // destroy the renderer (a unique pointer so the dtor will be called
   // immediately.)
   _surfaceHolder = nullptr;
-#if defined(SK_GRAPHITE)
   updateTargetInfo();
-#endif
   releaseWindow();
 }
 
-void RNSkOpenGLCanvasProvider::surfaceSizeChanged(jobject jSurface, int width,
-                                                  int height, bool isSurface,
-                                                  bool highBitDepth) {
+void RNSkAndroidCanvasProvider::surfaceSizeChanged(jobject jSurface, int width,
+                                                   int height, bool isSurface,
+                                                   bool highBitDepth) {
   if (width == 0 && height == 0) {
     // Setting width/height to zero is nothing we need to care about when
     // it comes to invalidating the surface.
@@ -228,12 +175,10 @@ void RNSkOpenGLCanvasProvider::surfaceSizeChanged(jobject jSurface, int width,
     surfaceAvailable(jSurface, width, height, isSurface, highBitDepth);
   } else {
     _surfaceHolder->resize(width, height);
-#if defined(SK_GRAPHITE)
     updateTargetInfo();
-#endif
   }
 
   // Redraw after size change
-  _requestRedraw();
+  requestRedraw();
 }
 } // namespace RNSkia

package/android/cpp/rnskia-android/{RNSkOpenGLCanvasProvider.h → RNSkAndroidCanvasProvider.h}

@@ -6,35 +6,45 @@
 #include <mutex>
 #include <vector>
 
-#include "RNSkView.h"
+#include "RNSkCanvasProvider.h"
+#include "RNSkPlatformContext.h"
 #include "RNWindowContext.h"
 
 #include <android/native_window.h>
 
 namespace RNSkia {
 
-class RNSkOpenGLCanvasProvider
-    : public RNSkia::RNSkCanvasProvider,
-      public std::enable_shared_from_this<RNSkOpenGLCanvasProvider> {
+/**
+ * The ANativeWindow a SkiaView presents into: the Surface of a SurfaceView or
+ * a Surface created over the SurfaceTexture of a TextureView, configured as a
+ * Dawn surface (see DawnWindowContext).
+ */
+class RNSkAndroidCanvasProvider : public RNSkCanvasProvider {
 public:
-  RNSkOpenGLCanvasProvider(
-      std::function<void()> requestRedraw,
-      std::shared_ptr<RNSkia::RNSkPlatformContext> platformContext);
+  explicit RNSkAndroidCanvasProvider(
+      std::shared_ptr<RNSkPlatformContext> platformContext);
 
-  virtual ~RNSkOpenGLCanvasProvider();
+  virtual ~RNSkAndroidCanvasProvider();
 
   int getWidth() override;
 
   int getHeight() override;
 
-  bool renderToCanvas(const std::function<void(SkCanvas *)> &cb) override;
+  bool getTargetInfo(RNSkGraphiteTargetInfo *info) override;
 
-#if defined(SK_GRAPHITE)
-  bool getGraphiteTargetInfo(RNSkGraphiteTargetInfo *info) override;
+  bool getLayoutSize(int *width, int *height) override;
 
   bool presentRecordings(
       const std::vector<skgpu::graphite::Recording *> &recordings) override;
-#endif
+
+  bool presentImage(const sk_sp<SkImage> &image) override;
+
+  /**
+   The pixel size the backing view was laid out with. The surface it gets
+   (SurfaceView or TextureView) has exactly this size, so a frame recorded
+   before the surface exists already matches it. Main thread.
+   */
+  void setLayoutSize(int width, int height);
 
   void surfaceAvailable(jobject surface, int width, int height, bool isSurface,
                         bool highBitDepth);
@@ -52,13 +62,8 @@ private:
   // Gives back what acquireWindow() took. Call after the window context that
   // draws into the window is gone.
   void releaseWindow();
-#if !defined(SK_GRAPHITE)
-  // Lets the SurfaceTexture of a TextureView consume the previous frame.
-  void updateTexImage();
-#else
   // Copies the window's target description where any thread can read it.
   void updateTargetInfo();
-#endif
 
   std::unique_ptr<WindowContext> _surfaceHolder = nullptr;
   std::shared_ptr<RNSkPlatformContext> _platformContext;
@@ -67,13 +72,10 @@ private:
   // as the window and is released with it (a SurfaceView's Surface is owned by
   // the view).
   jobject _jSurface = nullptr;
-#if !defined(SK_GRAPHITE)
-  jobject _jSurfaceTexture = nullptr;
-  jmethodID _updateTexImageMethod = nullptr;
-#else
   std::mutex _targetInfoMutex;
   RNSkGraphiteTargetInfo _targetInfo;
   bool _hasTargetInfo = false;
-#endif
+  int _layoutWidth = 0;
+  int _layoutHeight = 0;
 };
 } // namespace RNSkia

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

@@ -10,11 +10,7 @@
 #include <memory>
 #include <string>
 
-#if defined(SK_GRAPHITE)
 #include "RNDawnContext.h"
-#else
-#include "OpenGLContext.h"
-#endif
 
 #include "AHardwareBufferUtils.h"
 #include "JniPlatformContext.h"
@@ -54,49 +50,13 @@ public:
 
   sk_sp<SkSurface> makeOffscreenSurface(int width, int height,
                                         bool useP3ColorSpace = false) override {
-#if defined(SK_GRAPHITE)
     return DawnContext::getInstance().MakeOffscreen(width, height,
                                                     useP3ColorSpace);
-#else
-    return OpenGLContext::getInstance().MakeOffscreen(width, height,
-                                                      useP3ColorSpace);
-#endif
   }
 
   sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
-#if defined(SK_GRAPHITE)
     return DawnContext::getInstance().MakeImageFromBuffer(buffer);
-#else
-    return OpenGLContext::getInstance().MakeImageFromBuffer(buffer);
-#endif
-  }
-
-#if !defined(SK_GRAPHITE)
-  sk_sp<SkImage> makeImageFromNativeTexture(const TextureInfo &texInfo,
-                                            int width, int height,
-                                            bool mipMapped) override {
-    GrGLTextureInfo textureInfo;
-    textureInfo.fTarget = (GrGLenum)texInfo.glTarget;
-    textureInfo.fID = (GrGLuint)texInfo.glID;
-    textureInfo.fFormat = (GrGLenum)texInfo.glFormat;
-    textureInfo.fProtected =
-        texInfo.glProtected ? skgpu::Protected::kYes : skgpu::Protected::kNo;
-
-    OpenGLContext::getInstance().makeCurrent();
-    if (glIsTexture(textureInfo.fID) == GL_FALSE) {
-      throw std::runtime_error("Invalid textureInfo");
-    }
-
-    GrBackendTexture backendTexture = GrBackendTextures::MakeGL(
-        width, height,
-        mipMapped ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo,
-        textureInfo);
-    return SkImages::BorrowTextureFrom(
-        OpenGLContext::getInstance().getDirectContext(), backendTexture,
-        kTopLeft_GrSurfaceOrigin, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType,
-        nullptr);
   }
-#endif
 
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override {
     auto jniVideo = _jniPlatformContext->createVideo(url);
@@ -112,13 +72,11 @@ public:
 
   uint64_t makeNativeBuffer(sk_sp<SkImage> image) override {
 #if __ANDROID_API__ >= 26
-#if defined(SK_GRAPHITE)
     // A Graphite GPU texture can't be read with readPixels(nullptr); read it
     // back to a raster image first or the buffer ends up uninitialized/black.
     if (image && image->isTextureBacked()) {
       image = DawnContext::getInstance().MakeRasterImage(image);
     }
-#endif
     auto bytesPerPixel = image->imageInfo().bytesPerPixel();
     int bytesPerRow = image->width() * bytesPerPixel;
     auto buf = SkData::MakeUninitialized(image->width() * image->height() *
@@ -229,47 +187,6 @@ public:
 #endif
   }
 
-#if !defined(SK_GRAPHITE)
-  GrDirectContext *getDirectContext() override {
-    return OpenGLContext::getInstance().getDirectContext();
-  }
-
-  const TextureInfo getTexture(sk_sp<SkImage> image) override {
-    GrBackendTexture texture;
-    if (!SkImages::GetBackendTextureFromImage(image, &texture, true)) {
-      throw std::runtime_error("Couldn't get backend texture from image.");
-    }
-    return getTextureInfo(texture);
-  }
-
-  const TextureInfo getTexture(sk_sp<SkSurface> surface) override {
-    GrBackendTexture texture = SkSurfaces::GetBackendTexture(
-        surface.get(), SkSurface::BackendHandleAccess::kFlushRead);
-    return getTextureInfo(texture);
-  }
-
-  static TextureInfo getTextureInfo(const GrBackendTexture &texture) {
-
-    if (!texture.isValid()) {
-      throw std::runtime_error("invalid backend texture");
-    }
-    GrGLTextureInfo textureInfo;
-    if (!GrBackendTextures::GetGLTextureInfo(texture, &textureInfo)) {
-      throw std::runtime_error("couldn't get OpenGL texture");
-    }
-
-    OpenGLContext::getInstance().makeCurrent();
-    glFlush();
-
-    TextureInfo texInfo;
-    texInfo.glProtected = textureInfo.isProtected();
-    texInfo.glID = textureInfo.fID;
-    texInfo.glFormat = textureInfo.fFormat;
-    texInfo.glTarget = textureInfo.fTarget;
-    return texInfo;
-  }
-#endif
-
   sk_sp<SkFontMgr> createFontMgr() override {
     return SkFontMgr_New_Android(nullptr, SkFontScanner_Make_FreeType());
   }

package/android/cpp/rnskia-android/RNSkAndroidVideo.cpp

@@ -7,11 +7,7 @@
 
 #include "RNSkLog.h"
 
-#if defined(SK_GRAPHITE)
 #include "RNDawnContext.h"
-#else
-#include "OpenGLContext.h"
-#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -59,11 +55,7 @@ sk_sp<SkImage> RNSkAndroidVideo::nextImage(double *timeStamp) {
   // Convert jobject to AHardwareBuffer
   AHardwareBuffer *buffer =
       AHardwareBuffer_fromHardwareBuffer(env, jHardwareBuffer);
-#if defined(SK_GRAPHITE)
   return DawnContext::getInstance().MakeImageFromBuffer(buffer);
-#else
-  return OpenGLContext::getInstance().MakeImageFromBuffer(buffer);
-#endif
 #else
   return nullptr;
 #endif

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

@@ -33,8 +33,7 @@ public class RNSkiaPackage extends BaseReactPackage implements ReactPackage {
     @Override
     public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
         return Arrays.<ViewManager>asList(
-            new SkiaPictureViewManager(),
-            new SkiaGraphiteViewManager()
+            new SkiaViewManager()
         );
     }
 

package/android/src/main/java/com/reactnative/skia/SkiaSurfaceView.java

@@ -11,12 +11,10 @@ import androidx.annotation.NonNull;
 public class SkiaSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
 
     SkiaViewAPI mApi;
-    boolean mDebug;
 
-    public SkiaSurfaceView(Context context, SkiaViewAPI api, boolean debug, boolean zOrderOnTop, boolean opaque) {
+    public SkiaSurfaceView(Context context, SkiaViewAPI api, boolean zOrderOnTop, boolean opaque) {
         super(context);
         mApi = api;
-        mDebug = debug;
         // Must be set before the surface is created.
         setZOrderOnTop(zOrderOnTop);
         setOpaque(opaque);

package/android/src/main/java/com/reactnative/skia/SkiaTextureView.java

@@ -4,7 +4,6 @@ import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.SurfaceTexture;
 import android.util.Log;
-import android.view.Surface;
 import android.view.TextureView;
 import androidx.annotation.NonNull;
 
@@ -14,23 +13,16 @@ public class SkiaTextureView extends TextureView implements TextureView.SurfaceT
     private String tag = "SkiaTextureView";
 
     SkiaViewAPI mApi;
-    boolean mDebug;
 
-    public SkiaTextureView(Context context, SkiaViewAPI api, boolean debug, boolean opaque) {
+    public SkiaTextureView(Context context, SkiaViewAPI api, boolean opaque) {
         super(context);
         mApi = api;
-        mDebug = debug;
         // An opaque TextureView lets the UI toolkit skip blending it; it can be
         // toggled on a live view.
         setOpaque(opaque);
         setSurfaceTextureListener(this);
     }
 
-    @Override
-    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
-        super.onLayout(changed, left, top, right, bottom);
-    }
-
     @Override
     public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surfaceTexture, int width, int height) {
         Log.i(tag, "onSurfaceTextureAvailable:  " + width + "x" + height);
@@ -49,15 +41,7 @@ public class SkiaTextureView extends TextureView implements TextureView.SurfaceT
         return true;
     }
 
-    private long _prevTimestamp = 0;
     @Override
     public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface) {
-        if (!mDebug) {
-            return;
-        }
-        long timestamp = surface.getTimestamp();
-        long frameDuration = (timestamp - _prevTimestamp)/1000000;
-        Log.i("SkiaTextureView", "onSurfaceTextureUpdated "+frameDuration+"ms");
-        _prevTimestamp = timestamp;
     }
 }