@nativescript/canvas 2.0.0-alpha.5 → 2.0.0-alpha.50

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

@@ -4,27 +4,61 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
 #include <unistd.h>
 #include <thread>
-#include "NativeScript/JSIRuntime.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#ifdef __APPLE__
+#include "NSOperationQueueWrapper.h"
+#endif
+#include "ObjectWrapperImpl.h"
 
-using namespace org::nativescript::canvas;
+class ImageAssetImpl: ObjectWrapperImpl{
+public:
+    
+    ImageAssetImpl(ImageAsset* asset);
 
-using namespace facebook;
+    ~ImageAssetImpl();
 
-class JSI_EXPORT ImageAssetImpl : public jsi::HostObject {
-public:
-    ImageAssetImpl(rust::Box<ImageAsset> asset);
+    ImageAsset* GetImageAsset();
+    
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static ImageAssetImpl *GetPointer(const v8::Local<v8::Object>& object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void Ctor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetWidth(v8::Local<v8::String> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetHeight(v8::Local<v8::String> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetError(v8::Local<v8::String> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void Scale(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromUrlSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromFileSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromBytesSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void SaveSync(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    ImageAsset &GetImageAsset();
 
 private:
-    rust::Box<ImageAsset> asset_;
+    ImageAsset* asset_;
 };

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

@@ -0,0 +1,189 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#include "ImageBitmapImpl.h"
+#include "Caches.h"
+
+ImageBitmapImpl::ImageBitmapImpl(ImageAsset* asset)
+        : bitmap_(asset) {}
+
+ImageBitmapImpl::~ImageBitmapImpl(){
+    canvas_native_image_asset_destroy(bitmap_);
+    this->bitmap_ = nullptr;
+}
+
+
+void ImageBitmapImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    canvasModule->Set(context, ConvertToV8String(isolate, "ImageBitmap"), func);
+}
+
+ImageBitmapImpl *ImageBitmapImpl::GetPointer(v8::Local<v8::Object> object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<ImageBitmapImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> ImageBitmapImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->ImageBitmapTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "ImageBitmap"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "width"), GetWidth);
+
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "height"), GetHeight);
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "close"), v8::FunctionTemplate::New(isolate, Close));
+
+
+    cache->ImageBitmapTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void
+ImageBitmapImpl::GetWidth(v8::Local<v8::String> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr && !ptr->closed_) {
+        auto ret = canvas_native_image_asset_width(ptr->GetImageAsset());
+        info.GetReturnValue().Set(ret);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+void
+ImageBitmapImpl::GetHeight(v8::Local<v8::String> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr && !ptr->closed_) {
+        auto ret = canvas_native_image_asset_height(ptr->GetImageAsset());
+        info.GetReturnValue().Set(ret);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+
+void ImageBitmapImpl::Close(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->closed_ = true;
+}
+
+Options
+ImageBitmapImpl::HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value> &options) {
+    Options ret;
+
+    if (options->IsObject()) {
+        auto context = isolate->GetCurrentContext();
+        auto config = options.As<v8::Object>();
+
+
+        v8::Local<v8::Value> flipYValue;
+
+        config->Get(context, ConvertToV8String(isolate, "flipY")).ToLocal(&flipYValue);
+
+        if (flipYValue->IsBoolean()) {
+            ret.flipY = flipYValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> premultiplyAlphaValue;
+        config->Get(context, ConvertToV8String(isolate, "premultiplyAlpha")).ToLocal(
+                &premultiplyAlphaValue);
+
+        if (premultiplyAlphaValue->IsString()) {
+            auto premultiplyAlpha = ConvertFromV8String(isolate, premultiplyAlphaValue);
+
+            if (premultiplyAlpha == "premultiply") {
+                ret.premultiplyAlpha = ImageBitmapPremultiplyAlphaPremultiply;
+            }
+
+            if (premultiplyAlpha == "none") {
+                ret.premultiplyAlpha = ImageBitmapPremultiplyAlphaNone;
+            }
+        }
+
+        v8::Local<v8::Value> colorSpaceConversionValue;
+        config->Get(context, ConvertToV8String(isolate, "colorSpaceConversion")).ToLocal(
+                &colorSpaceConversionValue);
+
+        if (colorSpaceConversionValue->IsString()) {
+            auto colorSpaceConversion = ConvertFromV8String(isolate, colorSpaceConversionValue);
+
+            if (colorSpaceConversion == "none") {
+                ret.colorSpaceConversion = ImageBitmapColorSpaceConversionNone;
+            }
+        }
+
+        v8::Local<v8::Value> resizeQualityValue;
+
+        config->Get(context, ConvertToV8String(isolate, "resizeQuality")).ToLocal(
+                &resizeQualityValue);
+
+        if (resizeQualityValue->IsString()) {
+            auto resizeQuality = ConvertFromV8String(isolate, resizeQualityValue);
+
+            if (resizeQuality == "medium") {
+                ret.resizeQuality = ImageBitmapResizeQualityMedium;
+            }
+
+            if (resizeQuality == "high") {
+                ret.resizeQuality = ImageBitmapResizeQualityHigh;
+            }
+
+            if (resizeQuality == "pixelated") {
+                ret.resizeQuality = ImageBitmapResizeQualityPixelated;
+            }
+        }
+
+        v8::Local<v8::Value> resizeWidthValue;
+        config->Get(context, ConvertToV8String(isolate, "resizeWidth")).ToLocal(&resizeWidthValue);
+
+        if (resizeWidthValue->IsNumber()) {
+            auto val = resizeWidthValue->NumberValue(context).ToChecked();
+            ret.resizeWidth = (float) val;
+        }
+
+        v8::Local<v8::Value> resizeHeightValue;
+
+        config->Get(context, ConvertToV8String(isolate, "resizeHeight")).ToLocal(
+                &resizeHeightValue);
+
+        if (resizeHeightValue->IsNumber()) {
+            auto val = resizeHeightValue->NumberValue(context).ToChecked();
+            ret.resizeHeight = (float) val;
+        }
+    }
+
+    return ret;
+}
+
+ImageAsset* ImageBitmapImpl::GetImageAsset() {
+    return this->bitmap_;
+}

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

@@ -4,38 +4,64 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
+#include "ImageAssetImpl.h"
 #include "Helpers.h"
-#import "NativeScript/JSIRuntime.h"
 #include <vector>
-using namespace org::nativescript::canvas;
+#include "ObjectWrapperImpl.h"
 
 struct Options {
     bool flipY = false;
-    ImageBitmapPremultiplyAlpha premultiplyAlpha = ImageBitmapPremultiplyAlpha::Default;
-    ImageBitmapColorSpaceConversion colorSpaceConversion = ImageBitmapColorSpaceConversion::Default;
-    ImageBitmapResizeQuality resizeQuality = ImageBitmapResizeQuality::Low;
+    ImageBitmapPremultiplyAlpha premultiplyAlpha = ImageBitmapPremultiplyAlpha::ImageBitmapPremultiplyAlphaDefault;
+    ImageBitmapColorSpaceConversion colorSpaceConversion = ImageBitmapColorSpaceConversion::ImageBitmapColorSpaceConversionDefault;
+    ImageBitmapResizeQuality resizeQuality = ImageBitmapResizeQuality::ImageBitmapResizeQualityLow;
     float resizeWidth = 0;
     float resizeHeight = 0;
 };
 
 
-using namespace facebook;
-
-class JSI_EXPORT ImageBitmapImpl : public jsi::HostObject {
+class ImageBitmapImpl : public ObjectWrapperImpl {
 public:
-    ImageBitmapImpl(rust::Box<ImageAsset> asset);
+    ImageBitmapImpl(ImageAsset *asset);
+
+    ~ImageBitmapImpl();
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, v8::Local<v8::External> asset) {
+        auto context = isolate->GetCurrentContext();
+        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);
+
+
+        object->SetAlignedPointerInInternalField(0, ptr);
+
+        impl->BindFinalizer(isolate, object);
+
+        return scope.Escape(object);
+    }
+
+    static Options HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value> &options);
+
+    ImageAsset *GetImageAsset();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static ImageBitmapImpl *GetPointer(v8::Local<v8::Object> object);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void GetWidth(v8::Local<v8::String> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    static Options HandleOptions(jsi::Runtime &runtime, const jsi::Value &options);
+    static void GetHeight(v8::Local<v8::String> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    ImageAsset &GetImageAsset();
+    static void Close(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    rust::Box<ImageAsset> bitmap_;
+    ImageAsset *bitmap_;
     bool closed_ = false;
 };

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

@@ -3,13 +3,91 @@
 //
 
 #pragma once
-#include "NativeScript/JSIRuntime.h"
 
-using namespace facebook;
+#include "Common.h"
+#ifdef __ANDROID__
+#include <android/looper.h>
+#include <cassert>
+#endif
+#include <unistd.h>
+#include <fcntl.h>
 
+
+#ifdef __APPLE__
+
+struct JSICallback {
+    v8::Isolate *isolate_;
+    std::shared_ptr<v8::Persistent<v8::Function>> callback_;
+    std::shared_ptr<v8::Persistent<v8::Value>> data_;
+
+    JSICallback(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+                v8::Local<v8::Value> data = v8::Local<v8::Value>()) : isolate_(isolate),
+                                                                             callback_(
+                                                                                     std::make_shared<v8::Persistent<v8::Function>>(
+                                                                                             isolate,
+                                                                                             callback)),
+                                                                             data_(std::make_shared<v8::Persistent<v8::Value>>(
+                                                                                     isolate,
+                                                                                     data)) {}
+    
+    ~JSICallback() {
+        auto callback = callback_.get();
+        if(callback != nullptr){
+            callback->Reset();
+        }
+        auto data = data_.get();
+        if(data != nullptr){
+            data->Reset();
+        }
+        
+        callback_ = nullptr;
+        data_ = nullptr;
+    }
+};
+
+
+#endif
+
+
+#ifdef __ANDROID__
 struct JSICallback {
-    std::shared_ptr<jsi::Value> value_;
-    std::shared_ptr<jsi::HostObject> data_;
+    int fd_[2];
+    ALooper *looper_;
+    v8::Isolate *isolate_;
+    std::shared_ptr<v8::Persistent<v8::Function>> callback_;
+    std::shared_ptr<v8::Persistent<v8::Value>> data_;
+
+    JSICallback(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+                v8::Local<v8::Value> data = v8::Local<v8::Value>()) : isolate_(isolate),
+                                                                             callback_(
+                                                                                     std::make_shared<v8::Persistent<v8::Function>>(
+                                                                                             isolate,
+                                                                                             callback)),
+                                                                             data_(std::make_shared<v8::Persistent<v8::Value>>(
+                                                                                     isolate,
+                                                                                     data)) {
+        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_);
+    }
 
-    JSICallback(std::shared_ptr<jsi::Value> value) : value_(std::move(value)) {}
+    ~JSICallback() {
+        ALooper_removeFd(looper_, fd_[0]);
+        close(fd_[0]);
+        ALooper_release(looper_);
+        auto callback = callback_.get();
+        if(callback != nullptr){
+            callback->Reset();
+        }
+        auto data = data_.get();
+        if(data != nullptr){
+            data->Reset();
+        }
+        callback_ = nullptr;
+        data_ = nullptr;
+    }
 };
+#endif

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

@@ -1,16 +1,96 @@
 //
-// Created by Osei Fortune on 17/03/2023.
+// Created by Osei Fortune on 10/03/2023.
 //
 
 #pragma once
-#include "NativeScript/JSIRuntime.h"
 
-using namespace facebook;
+#include "Common.h"
+#ifdef __ANDROID__
+#include <android/looper.h>
+#endif
+#include <unistd.h>
+#include <fcntl.h>
 
+
+#ifdef __APPLE__
 struct JSIReadFileCallback {
-    std::shared_ptr<jsi::Value> value_;
-    std::shared_ptr<jsi::Value> data_;
+    v8::Isolate *isolate_;
+    v8::Global<v8::Function> callback_;
+    U8Buffer* data_;
+    char* error_;
+    std::mutex lock_;
+
+    JSIReadFileCallback(v8::Isolate *isolate, v8::Local<v8::Function> callback) : isolate_(isolate),
+                                                                                  callback_(
+                                                                                          v8::Global<v8::Function>(
+                                                                                                  isolate,
+                                                                                                  callback)) {}
+
+    void SetData(U8Buffer* data) {
+        std::lock_guard<std::mutex> lock(lock_);
+        data_ = data;
+    }
 
-    JSIReadFileCallback(std::shared_ptr<jsi::Value> value) : value_(std::move(value)) {}
+    void SetError(char* error) {
+        std::lock_guard<std::mutex> lock(lock_);
+        error_ = error;
+    }
+
+    ~JSIReadFileCallback() {
+        callback_.Reset();
+        canvas_native_u8_buffer_destroy(data_);
+        data_ = nullptr;
+        
+        canvas_native_string_destroy(error_);
+        error_ = nullptr;
+    }
 };
 
+#endif
+
+#ifdef __ANDROID__
+struct JSIReadFileCallback {
+    int fd_[2];
+    ALooper *looper_;
+    v8::Isolate *isolate_;
+    v8::Global<v8::Function> callback_;
+    U8Buffer* data_;
+    char* error_;
+    std::mutex lock_;
+
+    JSIReadFileCallback(v8::Isolate *isolate, v8::Local<v8::Function> callback) : isolate_(isolate),
+                                                                                  callback_(
+                                                                                          v8::Global<v8::Function>(
+                                                                                                  isolate,
+                                                                                                  callback)) {
+        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_);
+    }
+
+    void SetData(U8Buffer* data) {
+        std::lock_guard<std::mutex> lock(lock_);
+        data_ = data;
+    }
+
+    void SetError(char* error) {
+        std::lock_guard<std::mutex> lock(lock_);
+        error_ = error;
+    }
+
+    ~JSIReadFileCallback() {
+        ALooper_removeFd(looper_, fd_[0]);
+        close(fd_[0]);
+        ALooper_release(looper_);
+        callback_.Reset();
+        canvas_native_u8_buffer_destroy(data_);
+        data_ = nullptr;
+        
+        canvas_native_string_destroy(error_);
+        error_ = nullptr;
+    }
+};
+#endif

package/platforms/ios/src/cpp/JSIRuntime.cpp

@@ -0,0 +1,21 @@
+//
+// Created by Osei Fortune on 14/12/2022.
+//
+
+#include "CanvasJSIModule.h"
+#include "JSIRuntime.h"
+
+
+extern "C" void NSMain(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto len = args.Length();
+
+    if (len != 5) {
+        auto errMsg = v8::String::NewFromUtf8(isolate, "Wrong number of arguments (expected 5)");
+        auto err = v8::Exception::Error(errMsg.ToLocalChecked());
+        isolate->ThrowException(err);
+        return;
+    }
+
+    CanvasJSIModule::install(isolate);
+}

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

@@ -0,0 +1,7 @@
+//
+// Created by Osei Fortune on 14/12/2022.
+//
+
+#include "CanvasJSIModule.h"
+
+extern "C" void NSMain(const v8::FunctionCallbackInfo <v8::Value> &args);

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

@@ -0,0 +1,31 @@
+//
+//  ObjectWrapperImpl.h
+//
+//  Created by Osei Fortune on 10/01/2024.
+//  Copyright © 2024 NativeScript. All rights reserved.
+//
+
+#ifndef ObjectWrapperImpl_h
+#define ObjectWrapperImpl_h
+
+#include "Common.h"
+
+class ObjectWrapperImpl {
+public:
+    void BindFinalizer(v8::Isolate *isolate, const v8::Local<v8::Object> &object) {
+        v8::HandleScope scopedHandle(isolate);
+        weakHandle_.Reset(isolate, object);
+        weakHandle_.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
+    }
+    
+    static void Finalizer(const v8::WeakCallbackInfo<ObjectWrapperImpl> &data) {
+        auto *pThis = data.GetParameter();
+        pThis->weakHandle_.Reset();
+        delete pThis;
+    }
+private:
+    v8::Global<v8::Object> weakHandle_;
+
+};
+
+#endif /* ObjectWrapperImpl_h */

package/platforms/ios/src/cpp/OneByteStringResource.cpp

@@ -0,0 +1,55 @@
+//
+// Created by Osei Fortune on 30/09/2023.
+//
+
+#include "OneByteStringResource.h"
+
+OneByteStringResource::OneByteStringResource(char *string) : string_(string),
+                                                             length_(strlen(string)) {
+
+}
+
+OneByteStringResource::OneByteStringResource(U8Buffer *buffer) : buffer_(buffer) {
+    string_ = (char *) canvas_native_u8_buffer_get_bytes(buffer);
+    length_ = canvas_native_u8_buffer_get_length(buffer);
+    usingBuffer_ = true;
+}
+
+OneByteStringResource::OneByteStringResource(CCow *cow) : cow_(cow) {
+    string_ = (char *) canvas_native_ccow_get_bytes(cow);
+    length_ = canvas_native_ccow_get_length(cow);
+    usingCow_ = true;
+}
+
+OneByteStringResource::OneByteStringResource(std::string string) : stdString_(std::move(string)) {
+    this->usingString = true;
+}
+
+OneByteStringResource::~OneByteStringResource() {
+    if (usingBuffer_) {
+        canvas_native_u8_buffer_destroy(buffer_);
+        this->string_ = nullptr;
+        this->length_ = 0;
+    }else if(usingCow_){
+        canvas_native_ccow_destroy(cow_);
+        this->string_ = nullptr;
+        this->length_ = 0;
+    }else if(usingString){
+        // noop
+    } else {
+        canvas_native_string_destroy((char *) this->string_);
+        this->string_ = nullptr;
+        this->length_ = 0;
+    }
+}
+
+const char *OneByteStringResource::data() const {
+    return this->string_;
+}
+
+size_t OneByteStringResource::length() const {
+    return this->length_;
+}
+
+
+