@shopify/react-native-skia 1.5.10 → 1.7.0

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

@@ -29,12 +29,14 @@ public:
   }
 
 protected:
-  virtual void surfaceAvailable(jobject surface, int width, int height) {
-    _skiaAndroidView->surfaceAvailable(surface, width, height);
+  virtual void surfaceAvailable(jobject surface, int width, int height,
+                                bool opaque) {
+    _skiaAndroidView->surfaceAvailable(surface, width, height, opaque);
   }
 
-  virtual void surfaceSizeChanged(jobject surface, int width, int height) {
-    _skiaAndroidView->surfaceSizeChanged(surface, width, height);
+  virtual void surfaceSizeChanged(jobject surface, int width, int height,
+                                  bool opaque) {
+    _skiaAndroidView->surfaceSizeChanged(surface, width, height, opaque);
   }
 
   virtual void surfaceDestroyed() { _skiaAndroidView->surfaceDestroyed(); }
@@ -53,7 +55,6 @@ protected:
         _skiaAndroidView->getSkiaView()->getNativeId(), nullptr);
     getSkiaManager()->unregisterSkiaView(
         _skiaAndroidView->getSkiaView()->getNativeId());
-    _skiaAndroidView->viewDidUnmount();
   }
 
 private:

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

@@ -46,12 +46,14 @@ public:
   }
 
 protected:
-  void surfaceAvailable(jobject surface, int width, int height) override {
-    JniSkiaBaseView::surfaceAvailable(surface, width, height);
+  void surfaceAvailable(jobject surface, int width, int height,
+                        bool opaque) override {
+    JniSkiaBaseView::surfaceAvailable(surface, width, height, opaque);
   }
 
-  void surfaceSizeChanged(jobject surface, int width, int height) override {
-    JniSkiaBaseView::surfaceSizeChanged(surface, width, height);
+  void surfaceSizeChanged(jobject surface, int width, int height,
+                          bool opaque) override {
+    JniSkiaBaseView::surfaceSizeChanged(surface, width, height, opaque);
   }
 
   void surfaceDestroyed() override { JniSkiaBaseView::surfaceDestroyed(); }

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

@@ -44,8 +44,8 @@ public:
       JniPlatformContext *platformContext)
       : _javaPart(jni::make_global(jThis)), _jsRuntime(runtime),
         _jsCallInvoker(jsCallInvoker),
-        _context(std::make_shared<RNSkAndroidPlatformContext>(
-            platformContext, runtime, jsCallInvoker)) {}
+        _context(std::make_shared<RNSkAndroidPlatformContext>(platformContext,
+                                                              jsCallInvoker)) {}
 
   std::shared_ptr<RNSkAndroidPlatformContext> getPlatformContext() {
     return _context;

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

@@ -48,12 +48,14 @@ public:
   }
 
 protected:
-  void surfaceAvailable(jobject surface, int width, int height) override {
-    JniSkiaBaseView::surfaceAvailable(surface, width, height);
+  void surfaceAvailable(jobject surface, int width, int height,
+                        bool opaque) override {
+    JniSkiaBaseView::surfaceAvailable(surface, width, height, opaque);
   }
 
-  void surfaceSizeChanged(jobject surface, int width, int height) override {
-    JniSkiaBaseView::surfaceSizeChanged(surface, width, height);
+  void surfaceSizeChanged(jobject surface, int width, int height,
+                          bool opaque) override {
+    JniSkiaBaseView::surfaceSizeChanged(surface, width, height, opaque);
   }
 
   void surfaceDestroyed() override { JniSkiaBaseView::surfaceDestroyed(); }

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <android/looper.h>
+#include <queue>
 #include <unistd.h>
 
 class MainThreadDispatcher {
@@ -27,6 +28,8 @@ public:
     return instance;
   }
 
+  bool isOnMainThread() { return ALooper_forThread() == mainLooper; }
+
   void post(std::function<void()> task) {
     // TODO: this is disabled for now but we can clean this up
     // if (ALooper_forThread() == mainLooper) {

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

@@ -16,6 +16,36 @@
 
 namespace RNSkia {
 
+class OpenGLSharedContext {
+public:
+  OpenGLSharedContext(const OpenGLSharedContext &) = delete;
+  OpenGLSharedContext &operator=(const OpenGLSharedContext &) = delete;
+
+  static OpenGLSharedContext &getInstance() {
+    static OpenGLSharedContext instance;
+    return instance;
+  }
+
+  gl::Display *getDisplay() { return _glDisplay.get(); }
+  gl::Context *getContext() { return _glContext.get(); }
+  gl::Surface *getSurface() { return _glSurface.get(); };
+  EGLConfig getConfig() { return _glConfig; }
+
+private:
+  std::unique_ptr<gl::Display> _glDisplay;
+  std::unique_ptr<gl::Context> _glContext;
+  std::unique_ptr<gl::Surface> _glSurface;
+  EGLConfig _glConfig;
+
+  OpenGLSharedContext() {
+    _glDisplay = std::make_unique<gl::Display>();
+    _glConfig = _glDisplay->chooseConfig();
+    _glContext = _glDisplay->makeContext(_glConfig, nullptr);
+    _glSurface = _glDisplay->makePixelBufferSurface(_glConfig, 1, 1);
+    _glContext->makeCurrent(_glSurface.get());
+  }
+};
+
 class OpenGLContext {
 public:
   friend class OpenGLWindowContext;
@@ -39,8 +69,11 @@ public:
     }
 
     // Create texture
+    auto GL_RGBA8 = 0x8058;
+    auto format = GrBackendFormats::MakeGL(GL_RGBA8, GL_TEXTURE_2D);
     auto texture = _directContext->createBackendTexture(
-        width, height, colorType, skgpu::Mipmapped::kNo, GrRenderable::kYes);
+        width, height, format, SkColors::kTransparent, skgpu::Mipmapped::kNo,
+        GrRenderable::kYes);
 
     if (!texture.isValid()) {
       RNSkLogger::logToConsole("couldn't create offscreen texture %dx%d", width,
@@ -128,24 +161,26 @@ public:
   // TODO: remove width, height
   std::unique_ptr<WindowContext> MakeWindow(ANativeWindow *window, int width,
                                             int height) {
+    auto display = OpenGLSharedContext::getInstance().getDisplay();
     return std::make_unique<OpenGLWindowContext>(
-        _directContext.get(), _glDisplay.get(), _glContext.get(), window);
+        _directContext.get(), display, _glContext.get(), window,
+        OpenGLSharedContext::getInstance().getConfig());
   }
 
   GrDirectContext *getDirectContext() { return _directContext.get(); }
+  void makeCurrent() { _glContext->makeCurrent(_glSurface.get()); }
 
 private:
-  EGLConfig _glConfig;
-  std::unique_ptr<gl::Display> _glDisplay;
   std::unique_ptr<gl::Context> _glContext;
   std::unique_ptr<gl::Surface> _glSurface;
   sk_sp<GrDirectContext> _directContext;
 
   OpenGLContext() {
-    _glDisplay = std::make_unique<gl::Display>();
-    _glConfig = _glDisplay->chooseConfig();
-    _glContext = _glDisplay->makeContext(_glConfig, nullptr);
-    _glSurface = _glDisplay->makePixelBufferSurface(_glConfig, 1, 1);
+    auto display = OpenGLSharedContext::getInstance().getDisplay();
+    auto sharedContext = OpenGLSharedContext::getInstance().getContext();
+    auto glConfig = OpenGLSharedContext::getInstance().getConfig();
+    _glContext = display->makeContext(glConfig, sharedContext);
+    _glSurface = display->makePixelBufferSurface(glConfig, 1, 1);
     _glContext->makeCurrent(_glSurface.get());
     auto backendInterface = GrGLMakeNativeInterface();
     _directContext = GrDirectContexts::MakeGL(backendInterface);
@@ -156,4 +191,4 @@ private:
   }
 };
 
-} // namespace RNSkia
+} // namespace RNSkia

package/android/cpp/rnskia-android/OpenGLWindowContext.cpp

@@ -53,7 +53,6 @@ sk_sp<SkSurface> OpenGLWindowContext::getSurface() {
 
 void OpenGLWindowContext::present() {
   _glContext->makeCurrent(_glSurface.get());
-  // TODO: is flushAndSubmit needed here?
   _directContext->flushAndSubmit();
   _glSurface->present();
 }

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

@@ -34,11 +34,11 @@ namespace RNSkia {
 class OpenGLWindowContext : public WindowContext {
 public:
   OpenGLWindowContext(GrDirectContext *directContext, gl::Display *display,
-                      gl::Context *glContext, ANativeWindow *window)
+                      gl::Context *glContext, ANativeWindow *window,
+                      EGLConfig config)
       : _directContext(directContext), _display(display), _glContext(glContext),
         _window(window) {
     ANativeWindow_acquire(_window);
-    auto config = display->chooseConfig();
     _glSurface = display->makeWindowSurface(config, _window);
   }
 

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

@@ -20,7 +20,6 @@
 #include "MainThreadDispatcher.h"
 #include "RNSkAndroidVideo.h"
 #include "RNSkPlatformContext.h"
-
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
@@ -34,9 +33,9 @@ namespace jsi = facebook::jsi;
 class RNSkAndroidPlatformContext : public RNSkPlatformContext {
 public:
   RNSkAndroidPlatformContext(
-      JniPlatformContext *jniPlatformContext, jsi::Runtime *runtime,
+      JniPlatformContext *jniPlatformContext,
       std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker)
-      : RNSkPlatformContext(runtime, jsCallInvoker,
+      : RNSkPlatformContext(jsCallInvoker,
                             jniPlatformContext->getPixelDensity()),
         _jniPlatformContext(jniPlatformContext) {}
 
@@ -78,6 +77,31 @@ public:
 #endif
   }
 
+  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 new 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);
+  }
+
   std::shared_ptr<RNSkVideo> createVideo(const std::string &url) override {
     auto jniVideo = _jniPlatformContext->createVideo(url);
     return std::make_shared<RNSkAndroidVideo>(jniVideo);
@@ -149,6 +173,40 @@ public:
 #endif
   }
 
+  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 getJSITextureInfo(texture);
+  }
+
+  const TextureInfo getTexture(sk_sp<SkSurface> surface) override {
+    GrBackendTexture texture = SkSurfaces::GetBackendTexture(
+        surface.get(), SkSurface::BackendHandleAccess::kFlushRead);
+    return getJSITextureInfo(texture);
+  }
+
+  static const TextureInfo getJSITextureInfo(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;
+  }
+
 #if !defined(SK_GRAPHITE)
   GrDirectContext *getDirectContext() override {
     return OpenGLContext::getInstance().getDirectContext();

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

@@ -11,18 +11,18 @@ namespace RNSkia {
 
 class RNSkBaseAndroidView {
 public:
-  virtual void surfaceAvailable(jobject surface, int width, int height) = 0;
+  virtual void surfaceAvailable(jobject surface, int width, int height,
+                                bool opaque) = 0;
 
   virtual void surfaceDestroyed() = 0;
 
-  virtual void surfaceSizeChanged(jobject surface, int width, int height) = 0;
+  virtual void surfaceSizeChanged(jobject surface, int width, int height,
+                                  bool opaque) = 0;
 
   virtual float getPixelDensity() = 0;
 
   virtual void setShowDebugInfo(bool show) = 0;
 
-  virtual void viewDidUnmount() = 0;
-
   virtual std::shared_ptr<RNSkView> getSkiaView() = 0;
 };
 
@@ -34,12 +34,10 @@ public:
           std::make_shared<RNSkOpenGLCanvasProvider>(
               std::bind(&RNSkia::RNSkView::requestRedraw, this), context)) {}
 
-  void surfaceAvailable(jobject surface, int width, int height) override {
+  void surfaceAvailable(jobject surface, int width, int height,
+                        bool opaque) override {
     std::static_pointer_cast<RNSkOpenGLCanvasProvider>(T::getCanvasProvider())
-        ->surfaceAvailable(surface, width, height);
-
-    // Try to render directly when the surface has been set so that
-    // we don't have to wait until the draw loop returns.
+        ->surfaceAvailable(surface, width, height, opaque);
     RNSkView::redraw();
   }
 
@@ -48,9 +46,10 @@ public:
         ->surfaceDestroyed();
   }
 
-  void surfaceSizeChanged(jobject surface, int width, int height) override {
+  void surfaceSizeChanged(jobject surface, int width, int height,
+                          bool opaque) override {
     std::static_pointer_cast<RNSkOpenGLCanvasProvider>(T::getCanvasProvider())
-        ->surfaceSizeChanged(surface, width, height);
+        ->surfaceSizeChanged(surface, width, height, opaque);
     // This is only need for the first time to frame, this renderImmediate call
     // will invoke updateTexImage for the previous frame
     RNSkView::redraw();
@@ -62,8 +61,6 @@ public:
 
   void setShowDebugInfo(bool show) override { T::setShowDebugOverlays(show); }
 
-  void viewDidUnmount() override {}
-
   std::shared_ptr<RNSkView> getSkiaView() override {
     return T::shared_from_this();
   }

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

@@ -46,22 +46,24 @@ float RNSkOpenGLCanvasProvider::getScaledHeight() {
 
 bool RNSkOpenGLCanvasProvider::renderToCanvas(
     const std::function<void(SkCanvas *)> &cb) {
-  JNIEnv *env = facebook::jni::Environment::current();
   if (_surfaceHolder != nullptr && cb != nullptr) {
     // Get the surface
     auto surface = _surfaceHolder->getSurface();
-    env->CallVoidMethod(_jSurfaceTexture, _updateTexImageMethod);
-
-    // Check for exceptions
-    if (env->ExceptionCheck()) {
-      RNSkLogger::logToConsole("updateAndRelease() failed. The exception above "
-                               "can safely be ignored");
-      env->ExceptionClear();
+    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();
+      }
     }
     if (surface) {
       // Draw into canvas using callback
       cb(surface->getCanvas());
-
       // Swap buffers and show on screen
       _surfaceHolder->present();
       return true;
@@ -74,32 +76,36 @@ bool RNSkOpenGLCanvasProvider::renderToCanvas(
 }
 
 void RNSkOpenGLCanvasProvider::surfaceAvailable(jobject jSurfaceTexture,
-                                                int width, int height) {
-  // If the surface is 0, we can skip it
-  if (width == 0 && height == 0) {
-    return;
-  }
+                                                int width, int height,
+                                                bool opaque) {
+  // Release the old surface
+  _surfaceHolder = nullptr;
+
   // Create renderer!
+  ANativeWindow *window = nullptr;
   JNIEnv *env = facebook::jni::Environment::current();
-
-  _jSurfaceTexture = env->NewGlobalRef(jSurfaceTexture);
-  jclass surfaceClass = env->FindClass("android/view/Surface");
-  jmethodID surfaceConstructor = env->GetMethodID(
-      surfaceClass, "<init>", "(Landroid/graphics/SurfaceTexture;)V");
-  // Create a new Surface instance
-  jobject jSurface =
-      env->NewObject(surfaceClass, surfaceConstructor, jSurfaceTexture);
-
-  jclass surfaceTextureClass = env->GetObjectClass(_jSurfaceTexture);
-  _updateTexImageMethod =
-      env->GetMethodID(surfaceTextureClass, "updateTexImage", "()V");
-
-  // Acquire the native window from the Surface
-  auto window = ANativeWindow_fromSurface(env, jSurface);
-  // Clean up local references
-  env->DeleteLocalRef(jSurface);
-  env->DeleteLocalRef(surfaceClass);
-  env->DeleteLocalRef(surfaceTextureClass);
+  if (!opaque) {
+    _jSurfaceTexture = env->NewGlobalRef(jSurfaceTexture);
+    jclass surfaceClass = env->FindClass("android/view/Surface");
+    jmethodID surfaceConstructor = env->GetMethodID(
+        surfaceClass, "<init>", "(Landroid/graphics/SurfaceTexture;)V");
+    // Create a new Surface instance
+    auto jSurface =
+        env->NewObject(surfaceClass, surfaceConstructor, jSurfaceTexture);
+    window = ANativeWindow_fromSurface(env, jSurface);
+
+    jclass surfaceTextureClass = env->GetObjectClass(_jSurfaceTexture);
+    _updateTexImageMethod =
+        env->GetMethodID(surfaceTextureClass, "updateTexImage", "()V");
+
+    // Acquire the native window from the Surface
+    // Clean up local references
+    env->DeleteLocalRef(jSurface);
+    env->DeleteLocalRef(surfaceClass);
+    env->DeleteLocalRef(surfaceTextureClass);
+  } else {
+    window = ANativeWindow_fromSurface(env, jSurfaceTexture);
+  }
 #if defined(SK_GRAPHITE)
   _surfaceHolder = DawnContext::getInstance().MakeWindow(window, width, height);
 #else
@@ -121,8 +127,8 @@ void RNSkOpenGLCanvasProvider::surfaceDestroyed() {
   }
 }
 
-void RNSkOpenGLCanvasProvider::surfaceSizeChanged(jobject jSurfaceTexture,
-                                                  int width, int height) {
+void RNSkOpenGLCanvasProvider::surfaceSizeChanged(jobject jSurface, int width,
+                                                  int height, bool opaque) {
   if (width == 0 && height == 0) {
     // Setting width/height to zero is nothing we need to care about when
     // it comes to invalidating the surface.
@@ -131,7 +137,7 @@ void RNSkOpenGLCanvasProvider::surfaceSizeChanged(jobject jSurfaceTexture,
 
   if (_surfaceHolder == nullptr) {
     _surfaceHolder = nullptr;
-    surfaceAvailable(jSurfaceTexture, width, height);
+    surfaceAvailable(jSurface, width, height, opaque);
   } else {
     _surfaceHolder->resize(width, height);
   }

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

@@ -27,11 +27,11 @@ public:
 
   bool renderToCanvas(const std::function<void(SkCanvas *)> &cb) override;
 
-  void surfaceAvailable(jobject surface, int width, int height);
+  void surfaceAvailable(jobject surface, int width, int height, bool opaque);
 
   void surfaceDestroyed();
 
-  void surfaceSizeChanged(jobject jSurface, int width, int height);
+  void surfaceSizeChanged(jobject jSurface, int width, int height, bool opaque);
 
 private:
   std::unique_ptr<WindowContext> _surfaceHolder = nullptr;

package/android/cpp/rnskia-android/gl/Display.h

@@ -43,6 +43,8 @@ public:
 
     EGLint att[] = {EGL_RENDERABLE_TYPE,
                     EGL_OPENGL_ES2_BIT,
+                    EGL_SURFACE_TYPE,
+                    EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
                     EGL_ALPHA_SIZE,
                     8,
                     EGL_BLUE_SIZE,

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

@@ -0,0 +1,113 @@
+package com.shopify.reactnative.skia;
+
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.PixelFormat;
+import android.hardware.HardwareBuffer;
+import android.media.Image;
+import android.media.ImageReader;
+import android.os.Build;
+import android.util.Log;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+@SuppressLint("ViewConstructor")
+@RequiresApi(api = Build.VERSION_CODES.Q)
+public class SkiaAHBView extends View implements ImageReader.OnImageAvailableListener {
+
+    private ImageReader mReader;
+
+    private Bitmap mBitmap = null;
+
+    private final Matrix matrix = new Matrix();
+
+    SkiaViewAPI mApi;
+    boolean mDebug;
+
+    public SkiaAHBView(Context context, SkiaViewAPI api, boolean debug) {
+        super(context);
+        mApi = api;
+        mDebug = debug;
+    }
+
+    private ImageReader createReader() {
+        ImageReader reader = ImageReader.newInstance(getWidth(), getHeight(), PixelFormat.RGBA_8888, 2, HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE |
+                HardwareBuffer.USAGE_GPU_COLOR_OUTPUT);
+        reader.setOnImageAvailableListener(this, null);
+        return reader;
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+        int width = getWidth();
+        int height = getHeight();
+        if (mReader == null) {
+            mReader = createReader();
+            mApi.onSurfaceCreated(mReader.getSurface(), width, height);
+        } else {
+            mReader = createReader();
+            mApi.onSurfaceChanged(mReader.getSurface(), width, height);
+        }
+    }
+
+    @Override
+    public void onImageAvailable(ImageReader reader) {
+        try (Image image = reader.acquireLatestImage()) {
+            if (image != null) {
+                HardwareBuffer hb = image.getHardwareBuffer();
+                if (mDebug) {
+                    textureUpdated(image.getTimestamp());
+                }
+                if (hb != null) {
+                    Bitmap bitmap = Bitmap.wrapHardwareBuffer(hb, null);
+                    if (bitmap != null) {
+                        mBitmap = bitmap;
+                        hb.close();
+                        invalidate();
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    protected void onDraw(@NonNull Canvas canvas) {
+        super.onDraw(canvas);
+        if (mBitmap != null) {
+            float viewWidth = getWidth();
+            float viewHeight = getHeight();
+            float bitmapWidth = mBitmap.getWidth();
+            float bitmapHeight = mBitmap.getHeight();
+
+            // Calculate the scale factors
+            float scaleX = viewWidth / bitmapWidth;
+            float scaleY = viewHeight / bitmapHeight;
+
+            // Reset the matrix and apply scaling
+            matrix.reset();
+            matrix.setScale(scaleX, scaleY);
+
+            canvas.drawBitmap(mBitmap, matrix, null);
+        }
+    }
+
+    private long _prevTimestamp = 0;
+    public void textureUpdated(long ts) {
+        long frameDuration = (ts - _prevTimestamp)/1000000;
+        Log.i("SkiaAHBView", "onSurfaceTextureUpdated "+frameDuration+"ms");
+        _prevTimestamp = ts;
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        mApi.onSurfaceDestroyed();
+    }
+}