@nativescript/canvas 2.0.0-webgpu.1 → 2.0.0-webgpu.3

package/platforms/ios/src/NSOperationQueueWrapper.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <functional>
 class NSOperationQueueWrapper {
 public:

package/platforms/ios/src/cpp/AsyncCallback.h

@@ -0,0 +1,206 @@
+//
+// Created by Osei Fortune on 05/08/2024.
+//
+
+#pragma once
+
+#include "Common.h"
+
+#ifdef __ANDROID__
+
+#include <android/looper.h>
+#include <cassert>
+
+#endif
+
+#ifdef __APPLE__
+#include "NSOperationQueueWrapper.h"
+#endif
+
+#include <unistd.h>
+#include <fcntl.h>
+
+typedef void(*CompleteCallback)(bool success, void *data);
+
+
+#ifdef __APPLE__
+struct AsyncCallback {
+
+    struct Inner {
+        NSOperationQueueWrapper* current_queue = nullptr;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Function> callback_;
+        CompleteCallback completeCallback_;
+        CompleteCallback completeCallbackWrapper_;
+        bool isPrepared_ = false;
+        void* data = nullptr;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Function>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+
+            this->completeCallbackWrapper_ = [](bool success, void *data){
+                if(data != nullptr){
+                    auto* callback = static_cast<AsyncCallback*>(data);
+                    auto inner = callback->inner_.get();
+                    if(inner == nullptr || inner->current_queue == nullptr){
+                        return;
+                    }
+                    inner->current_queue->addOperation([success, data, inner, callback](){
+                        inner->completeCallback_(success, data);
+                       // delete callback;
+                    });
+                }
+            };
+        }
+
+        void prepare(){
+            current_queue = new NSOperationQueueWrapper(true);
+            isPrepared_ = true;
+        }
+
+        void execute(bool complete, AsyncCallback* callback){
+            completeCallbackWrapper_(complete, callback);
+        }
+
+        ~Inner() {
+            callback_.Reset();
+        }
+    };
+
+    std::shared_ptr<Inner> inner_;
+
+
+    void prepare(){
+        auto inner = this->inner_.get();
+        if(inner == nullptr){return;}
+        inner->prepare();
+    }
+
+    void execute(bool complete) {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete, this);
+    }
+
+
+    explicit AsyncCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+
+    AsyncCallback(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+                  CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {
+    }
+
+
+};
+#endif
+
+#ifdef __ANDROID__
+
+struct AsyncCallback {
+
+    struct Inner {
+        int fd_[2];
+        ALooper *looper_;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Function> callback_;
+        CompleteCallback completeCallback_;
+        bool isPrepared_ = false;
+        void* data;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Function>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+        }
+
+        void prepare() {
+            // release previous looper
+            if (isPrepared_) {
+                ALooper_removeFd(looper_, fd_[0]);
+                close(fd_[0]);
+                fd_[0] = -1;
+                fd_[1] = -1;
+                ALooper_release(looper_);
+            }
+
+            auto res = pipe(fd_);
+            assert(res != -1);
+            res = fcntl(fd_[1], F_SETFL, O_NONBLOCK);
+            assert(res != -1);
+            looper_ = ALooper_prepare(0);
+            ALooper_acquire(looper_);
+
+            isPrepared_ = true;
+        }
+
+        void execute(bool complete) const {
+            if (!isPrepared_) { return; }
+            write(fd_[1],
+                  &complete,
+                  sizeof(bool));
+        }
+
+        ~Inner() {
+            if(!isPrepared_){
+                return;
+            }
+            ALooper_removeFd(looper_, fd_[0]);
+            close(fd_[0]);
+            ALooper_release(looper_);
+            callback_.Reset();
+        }
+    };
+
+    std::shared_ptr<Inner> inner_;
+
+    void prepare() const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->prepare();
+        auto looper = inner->looper_;
+        auto fd = inner->fd_[0];
+
+        auto data = new AsyncCallback(this->inner_);
+        ALooper_addFd(looper,
+                      fd,
+                      ALOOPER_POLL_CALLBACK,
+                      ALOOPER_EVENT_INPUT,
+                      [](int fd, int events,
+                         void *data) {
+                          auto cb = static_cast<AsyncCallback *>(data);
+                          bool done = false;
+                          read(fd, &done,
+                               sizeof(bool));
+                          cb->inner_->completeCallback_(done, data);
+                          return 0;
+                      }, (void *) data);
+
+        ALooper_wake(looper);
+    }
+
+    void execute(bool complete) const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete);
+    }
+
+
+    explicit AsyncCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+
+    AsyncCallback(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+                  CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {
+    }
+
+
+};
+
+#endif

package/platforms/ios/src/cpp/CanvasJSIModule.cpp

@@ -324,7 +324,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 
                 auto asset = canvas_native_image_asset_create();
 
-                auto shared_asset = canvas_native_image_asset_shared_clone(asset);
+                auto shared_asset = canvas_native_image_asset_reference(asset);
 
                 auto ret = new ImageBitmapImpl(asset);
 
@@ -401,7 +401,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeHeight,
                                         shared_asset);
 
-                                canvas_native_image_asset_destroy(shared_asset);
+                                canvas_native_image_asset_release(shared_asset);
 
                                 write(jsi_callback->fd_[1],
                                       &done,
@@ -440,7 +440,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeHeight,
                                     shared_asset);
 
-                            canvas_native_image_asset_destroy(shared_asset);
+                            canvas_native_image_asset_release(shared_asset);
 
                             write(jsi_callback->fd_[1],
                                   &done,
@@ -479,7 +479,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeHeight,
                                         shared_asset);
 
-                                canvas_native_image_asset_destroy(shared_asset);
+                                canvas_native_image_asset_release(shared_asset);
 
 
                                 auto main_task = [jsi_callback, current_queue, done]() {
@@ -553,7 +553,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeHeight,
                                     shared_asset);
 
-                            canvas_native_image_asset_destroy(shared_asset);
+                            canvas_native_image_asset_release(shared_asset);
 
                             auto main_task = [jsi_callback, current_queue, done]() {
 
@@ -601,7 +601,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
             } else if (len == 5 || len == 6) {
                 auto asset = canvas_native_image_asset_create();
 
-                auto shared_asset = canvas_native_image_asset_shared_clone(asset);
+                auto shared_asset = canvas_native_image_asset_reference(asset);
 
                 auto ret = new ImageBitmapImpl(asset);
 
@@ -686,7 +686,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeWidth,
                                         options.resizeHeight, shared_asset);
 
-                                canvas_native_image_asset_destroy(shared_asset);
+                                canvas_native_image_asset_release(shared_asset);
 
 
                                 write(jsi_callback->fd_[1],
@@ -736,7 +736,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeWidth,
                                     options.resizeHeight, shared_asset);
 
-                            canvas_native_image_asset_destroy(shared_asset);
+                            canvas_native_image_asset_release(shared_asset);
 
 
                             write(jsi_callback->fd_[1],
@@ -786,7 +786,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeWidth,
                                         options.resizeHeight, shared_asset);
 
-                                canvas_native_image_asset_destroy(shared_asset);
+                                canvas_native_image_asset_release(shared_asset);
 
 
                                 auto main_task = [jsi_callback, current_queue, done]() {
@@ -871,7 +871,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeWidth,
                                     options.resizeHeight, shared_asset);
 
-                            canvas_native_image_asset_destroy(shared_asset);
+                            canvas_native_image_asset_release(shared_asset);
 
                             auto main_task = [jsi_callback, current_queue, done]() {
 
@@ -927,7 +927,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
         }
     }
 
-    auto type = GetNativeType(image);
+    auto type = ObjectWrapperImpl::GetNativeType(image);
 
     if (len == 1 || len == 2) {
         if (len == 2) {
@@ -1183,7 +1183,7 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
 
                     jsi_callback->SetError(const_cast<char *>(error));
                 }
-                canvas_native_helper_destroy(ret);
+                canvas_native_helper_release(ret);
 
                 write(jsi_callback->fd_[1],
                       &done,
@@ -1221,7 +1221,7 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
             jsi_callback->SetError((char*)error);
         }
 
-        canvas_native_helper_destroy(ret);
+        canvas_native_helper_release(ret);
 
         auto main_task = [jsi_callback, current_queue, queue, done]() {
 

package/platforms/ios/src/cpp/Helpers.h

@@ -8,6 +8,8 @@
 #include "Common.h"
 #include "OneByteStringResource.h"
 #include "v8-fast-api-calls.h"
+#include "AsyncCallback.h"
+#include "PromiseCallback.h"
 //#ifdef __APPLE__
 //#ifdef __OBJC__
 //#include <Foundation/Foundation.h>
@@ -17,19 +19,6 @@
 //#endif
 //#endif
 
-
-struct AsyncCallback {
-    v8::Isolate *isolate;
-    v8::Global<v8::Function> callback;
-    void *data;
-};
-
-struct PromiseCallback {
-    v8::Isolate *isolate;
-    v8::Global<v8::Promise::Resolver> callback;
-    void *data;
-};
-
 static const char *LOG_TAG = "JS";
 static int m_maxLogcatObjectSize = 4096;
 
@@ -81,89 +70,6 @@ static void LogToConsole(const std::string &message) {
 #endif
 }
 
-enum class NativeMask {
-    Type = 1
-};
-
-enum class NativeType {
-    None,
-    CanvasGradient,
-    CanvasPattern,
-    ImageData,
-    ImageAsset,
-    CanvasRenderingContext2D,
-    WebGLRenderingContextBase,
-    Path2D,
-    Matrix,
-    ImageBitmap,
-    TextMetrics,
-
-    WebGLQuery,
-    WebGLProgram,
-    WebGLShader,
-    WebGLBuffer,
-    WebGLFramebuffer,
-    WebGLRenderbuffer,
-    WebGLTexture,
-    WebGLActiveInfo,
-    OES_fbo_render_mipmap,
-    EXT_blend_minmax,
-    EXT_color_buffer_half_float,
-    EXT_disjoint_timer_query,
-    EXT_sRGB,
-    EXT_shader_texture_lod,
-    EXT_texture_filter_anisotropic,
-    OES_element_index_uint,
-    OES_standard_derivatives,
-    OES_texture_float,
-    OES_texture_float_linear,
-    OES_texture_half_float_linear,
-    OES_texture_half_float,
-    WEBGL_color_buffer_float,
-    OES_vertex_array_object,
-    WebGLVertexArrayObject,
-    WEBGL_compressed_texture_atc,
-    WEBGL_compressed_texture_etc1,
-    WEBGL_compressed_texture_s3tc,
-    WEBGL_compressed_texture_s3tc_srgb,
-    WEBGL_compressed_texture_etc,
-    WEBGL_compressed_texture_pvrtc,
-    WEBGL_lose_context,
-    ANGLE_instanced_arrays,
-    WEBGL_depth_texture,
-    WEBGL_draw_buffers,
-    WebGLShaderPrecisionFormat,
-    WebGLUniformLocation,
-    WebGLSampler,
-    WebGLTransformFeedback,
-    WebGLSync,
-
-    GPUAdapter,
-    GPUSupportedLimits,
-    GPUDevice,
-    GPUQueue,
-    GPUBuffer,
-    GPUInstance,
-    GPUCanvasContext,
-    GPUTexture,
-    GPUAdapterInfo,
-    GPUCommandEncoder,
-    GPUComputePass,
-    GPUQuerySet,
-    GPUShaderModule,
-    GPUPipelineLayout,
-    GPURenderPipeline,
-    GPUBindGroupLayout,
-    GPUTextureView,
-    GPURenderPassEncoder,
-    GPUCommandBuffer,
-    GPUBindGroup,
-    GPUComputePipeline,
-    GPUSampler,
-    GPURenderBundleEncoder,
-    GPURenderBundle
-};
-
 inline static v8::Local<v8::String>
 ConvertToV8OneByteString(v8::Isolate *isolate, std::string string) {
     auto value = new OneByteStringResource(std::move(string));
@@ -207,74 +113,6 @@ ConvertFromV8String(v8::Isolate *isolate, const v8::Local<v8::Value> &value) {
 }
 
 
-static void SetPrivateValue(v8::Isolate *isolate, const v8::Local<v8::Object> &obj,
-                            const v8::Local<v8::String> &propName,
-                            const v8::Local<v8::Value> &value) {
-    v8::Local<v8::Context> context;
-    auto succcess = obj->GetCreationContext().ToLocal(&context);
-    v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, propName);
-    obj->SetPrivate(context, privateKey, value);
-}
-
-static v8::Local<v8::Value>
-GetPrivateValue(v8::Isolate *isolate, const v8::Local<v8::Object> &obj,
-                const v8::Local<v8::String> &propName) {
-    v8::Local<v8::Context> context;
-    auto succcess = obj->GetCreationContext().ToLocal(&context);
-    v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, propName);
-
-    v8::Maybe<bool> hasPrivate = obj->HasPrivate(context, privateKey);
-
-    if (!hasPrivate.FromMaybe(false)) {
-        return {};
-    }
-
-    v8::Local<v8::Value> result;
-
-    succcess = obj->GetPrivate(context, privateKey).ToLocal(&result);
-
-    return result;
-}
-
-static void SetNativeType(const v8::Local<v8::Object> &obj, NativeType type) {
-    auto value = (int32_t) type;
-    obj->SetAlignedPointerInInternalField(1, new int32_t(value));
-}
-
-inline static NativeType GetNativeType(const v8::Local<v8::Value> &obj) {
-    if (!obj.IsEmpty() && !obj->IsNullOrUndefined() && obj->IsObject() &&
-        obj.As<v8::Object>()->InternalFieldCount() > 1) {
-        auto info = obj.As<v8::Object>()->GetAlignedPointerFromInternalField(1);
-
-        if (info != nullptr) {
-            auto value = *static_cast<int32_t *>(info);
-            auto ret = value;
-            if (ret >= (int) NativeType::CanvasGradient &&
-                ret <= (int) NativeType::GPURenderBundle) {
-                return (NativeType) ret;
-            }
-        }
-    }
-
-    return NativeType::None;
-}
-
-
-//template<class T>
-//static inline void Finalizer(const v8::WeakCallbackInfo<T> &data) {
-//    auto *pThis = data.GetParameter();
-//    pThis->weakHandle_.Reset();
-//    delete pThis;
-//}
-
-//static inline void BindFinalizer(v8::Isolate *isolate, v8::Global<v8::Object> &weakHandle, const v8::Local<v8::Object> &object) {
-//    v8::HandleScope scopedHandle(isolate);
-//    weakHandle.Reset(isolate, object);
-//    weakHandle.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
-//}
-
-
-
 static void SetFastMethod(v8::Isolate *isolate,
                           v8::Local<v8::Template> that,
                           const char *name,

package/platforms/ios/src/cpp/ImageAssetImpl.cpp

@@ -15,7 +15,7 @@ ImageAssetImpl::ImageAssetImpl(ImageAsset *asset) : asset_(asset) {
 }
 
 ImageAssetImpl::~ImageAssetImpl() {
-    canvas_native_image_asset_destroy(this->GetImageAsset());
+    canvas_native_image_asset_release(this->GetImageAsset());
     asset_ = nullptr;
 }
 
@@ -122,12 +122,12 @@ void ImageAssetImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto ret = args.This();
 
-    SetNativeType(ret, NativeType::ImageAsset);
-
     auto image_asset = canvas_native_image_asset_create();
 
     auto object = new ImageAssetImpl(image_asset);
 
+    SetNativeType(object, NativeType::ImageAsset);
+
     ret->SetAlignedPointerInInternalField(0, object);
 
     object->BindFinalizer(isolate, ret);
@@ -179,7 +179,7 @@ ImageAssetImpl::GetReference(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto ptr = GetPointer(args.This());
     if (ptr != nullptr) {
         auto isolate = args.GetIsolate();
-        auto reference = canvas_native_image_asset_shared_clone(ptr->GetImageAsset());
+        auto reference = canvas_native_image_asset_reference(ptr->GetImageAsset());
         auto ret = std::to_string(canvas_native_image_asset_get_addr(reference));
         args.GetReturnValue().Set(ConvertToV8String(isolate, ret));
         return;
@@ -230,7 +230,7 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     auto url = ConvertFromV8String(isolate, args[0]);
 
-    auto asset = canvas_native_image_asset_shared_clone(ptr->asset_);
+    auto asset = canvas_native_image_asset_reference(ptr->asset_);
 
     auto callback = args[1].As<v8::Function>();
 
@@ -277,7 +277,7 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
                     const std::string &url) {
                 auto done = canvas_native_image_asset_load_from_url(asset, url.c_str());
 
-                canvas_native_image_asset_destroy(asset);
+                canvas_native_image_asset_release(asset);
 
                 write(jsi_callback->fd_[1],
                       &done,
@@ -346,7 +346,7 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
     auto task = [jsi_callback, current_queue, queue, asset, url]() {
 
         auto done = canvas_native_image_asset_load_from_url(asset, url.c_str());
-        canvas_native_image_asset_destroy(asset);
+        canvas_native_image_asset_release(asset);
 
         auto main_task = [jsi_callback, current_queue, queue, url, done]() {
 
@@ -412,7 +412,7 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     auto path = ConvertFromV8String(isolate, args[0]);
 
-    auto asset = canvas_native_image_asset_shared_clone(
+    auto asset = canvas_native_image_asset_reference(
             ptr->GetImageAsset());
 
     auto callback = args[1].As<v8::Function>();
@@ -461,7 +461,7 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
                 auto done = canvas_native_image_asset_load_from_path(asset, path.c_str());
 
-                canvas_native_image_asset_destroy(asset);
+                canvas_native_image_asset_release(asset);
 
                 write(jsi_callback->fd_[1],
                       &done,
@@ -482,7 +482,7 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
         auto done = canvas_native_image_asset_load_from_path(asset, path.c_str());
 
-        canvas_native_image_asset_destroy(asset);
+        canvas_native_image_asset_release(asset);
 
         auto main_task = [jsi_callback, current_queue, queue, done]() {
 
@@ -562,7 +562,7 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
 
     auto data = (uint8_t *) bytes->GetBackingStore()->Data();
 
-    auto asset = canvas_native_image_asset_shared_clone(ptr->GetImageAsset());
+    auto asset = canvas_native_image_asset_reference(ptr->GetImageAsset());
 
     auto callback = args[1].As<v8::Function>();
 
@@ -608,7 +608,7 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
 
                 auto done = canvas_native_image_asset_load_from_raw(asset, data, size);
 
-                canvas_native_image_asset_destroy(asset);
+                canvas_native_image_asset_release(asset);
 
                 write(jsi_callback->fd_[1],
                       &done,
@@ -631,7 +631,7 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
 
         auto done = canvas_native_image_asset_load_from_raw(asset, data, size);
 
-        canvas_native_image_asset_destroy(asset);
+        canvas_native_image_asset_release(asset);
 
         auto main_task = [jsi_callback, current_queue, queue, done]() {
 

package/platforms/ios/src/cpp/ImageBitmapImpl.cpp

@@ -9,7 +9,7 @@ ImageBitmapImpl::ImageBitmapImpl(ImageAsset* asset)
         : bitmap_(asset) {}
 
 ImageBitmapImpl::~ImageBitmapImpl(){
-    canvas_native_image_asset_destroy(bitmap_);
+    canvas_native_image_asset_release(bitmap_);
     this->bitmap_ = nullptr;
 }
 

package/platforms/ios/src/cpp/ImageBitmapImpl.h

@@ -30,11 +30,12 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = ImageBitmapImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::ImageBitmap);
 
         auto ptr = asset->Value();
         auto impl = static_cast<ObjectWrapperImpl *>(ptr);
 
+        SetNativeType(impl, NativeType::ImageBitmap);
+
 
         object->SetAlignedPointerInInternalField(0, ptr);
 

package/platforms/ios/src/cpp/JSIReadFileCallback.h

@@ -38,9 +38,9 @@ struct JSIReadFileCallback {
 
     ~JSIReadFileCallback() {
         callback_.Reset();
-        canvas_native_u8_buffer_destroy(data_);
+        canvas_native_u8_buffer_release(data_);
         data_ = nullptr;
-        
+
         canvas_native_string_destroy(error_);
         error_ = nullptr;
     }
@@ -86,9 +86,9 @@ struct JSIReadFileCallback {
         close(fd_[0]);
         ALooper_release(looper_);
         callback_.Reset();
-        canvas_native_u8_buffer_destroy(data_);
+        canvas_native_u8_buffer_release(data_);
         data_ = nullptr;
-        
+
         canvas_native_string_destroy(error_);
         error_ = nullptr;
     }