@nativescript/canvas 2.0.0-alpha.20 → 2.0.0-alpha.22

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

@@ -4,27 +4,59 @@
 
 #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
 
-using namespace org::nativescript::canvas;
+class ImageAssetImpl{
+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->GetInternalField(0).As<v8::External>()->Value();
+    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(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "ImageBitmap"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+    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,44 @@
 
 #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;
 
 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:
-    ImageBitmapImpl(rust::Box<ImageAsset> asset);
+    ImageBitmapImpl(ImageAsset* asset);
+    ~ImageBitmapImpl();
+
+    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,69 @@
 //
 
 #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)) {}
+};
+
+
+#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_);
+        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/OneByteStringResource.cpp

@@ -0,0 +1,25 @@
+//
+// Created by Osei Fortune on 30/09/2023.
+//
+
+#include "OneByteStringResource.h"
+
+OneByteStringResource::OneByteStringResource(char *string) : string_(string),
+                                                             length_(strlen(string)) {
+
+}
+
+OneByteStringResource::~OneByteStringResource() {
+    canvas_native_string_destroy((char *) this->string_);
+    this->string_ = nullptr;
+}
+
+const char *OneByteStringResource::data() const {
+    return this->string_;
+}
+
+size_t OneByteStringResource::length() const {
+    return this->length_;
+}
+
+

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

@@ -0,0 +1,21 @@
+//
+// Created by Osei Fortune on 30/09/2023.
+//
+
+#pragma once
+#include "Common.h"
+
+class OneByteStringResource : public v8::String::ExternalOneByteStringResource {
+public:
+    OneByteStringResource(char* string);
+    
+    ~OneByteStringResource();
+
+    const char* data() const override;
+    size_t length() const override;
+
+private:
+    const char* string_;
+    size_t length_;
+};
+

package/platforms/ios/src/cpp/RafImpl.cpp

@@ -0,0 +1,8 @@
+//
+// Created by Osei Fortune on 20/04/2022.
+//
+
+#include "RafImpl.h"
+
+RafImpl::RafImpl(OnRafCallback *rafCallback, intptr_t callback, Raf* raf) : rafCallback_(
+        rafCallback), callback_(callback), raf_(raf) {}

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

@@ -5,23 +5,26 @@
 #pragma once
 #pragma process_pending_includes
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
 #include <cstdint>
 #include "OnRafCallback.h"
-
-using namespace org::nativescript::canvas;
+#include "Common.h"
 
 class RafImpl {
 public:
-    RafImpl(OnRafCallback *rafCallback, intptr_t callback, rust::Box<Raf> raf);
+    RafImpl(OnRafCallback *rafCallback, intptr_t callback, Raf* raf);
+    
+    ~RafImpl(){
+        canvas_native_raf_destroy(this->GetRaf());
+        this->raf_ = nullptr;
+        delete rafCallback_;
+    }
 
-    Raf &GetRaf() {
-        return *this->raf_;
+    Raf *GetRaf() {
+        return this->raf_;
     }
 
 private:
     OnRafCallback *rafCallback_;
     intptr_t callback_;
-    rust::Box<Raf> raf_;
+    Raf* raf_;
 };