@nativescript/canvas 2.0.0-webgpu.10 → 2.0.0-webgpu.12

package/platforms/ios/src/NSOperationQueueWrapper.h

@@ -3,7 +3,7 @@
 #include <functional>
 class NSOperationQueueWrapper {
 public:
-    NSOperationQueueWrapper(bool currentQueue);
+    NSOperationQueueWrapper(bool currentQueue, bool serial = false);
     ~NSOperationQueueWrapper();
 
     void addOperation(std::function<void()> task);

package/platforms/ios/src/NSOperationQueueWrapper.mm

@@ -7,12 +7,16 @@
 
 @implementation NSOperationQueueWrapperObjC {
     NSOperationQueue* operationQueue;
+    __CFRunLoop* current;
+    BOOL isSerial;
 }
 
 - (instancetype)init {
     self = [super init];
     if (self) {
-        operationQueue = [[NSOperationQueue alloc] init];
+        isSerial = false;
+        operationQueue = NULL;
+        current = NULL;
     }
     return self;
 }
@@ -20,7 +24,15 @@
 -(instancetype)initWithCurrentQueue {
     self = [super init];
     if (self) {
-        operationQueue = [NSOperationQueue currentQueue];
+        current = CFRunLoopGetCurrent();
+    }
+    return self;
+}
+
+-(instancetype)initWithSerial:(BOOL)serial {
+    self = [super init];
+    if (self) {
+        isSerial = serial;
     }
     return self;
 }
@@ -28,11 +40,32 @@
 - (void)dealloc {}
 
 - (void)addOperation:(void (^)())task {
-    NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
-        task();
-    }];
     
-    [operationQueue addOperation:operation];
+    if(current != NULL){
+        if(current == CFRunLoopGetCurrent()){
+            task();
+        }else {
+            CFRunLoopPerformBlock(current, kCFRunLoopDefaultMode, ^{
+                task();
+            });
+            CFRunLoopWakeUp(current);
+        }
+    }else if(operationQueue != NULL){
+        NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
+            task();
+        }];
+        
+        [operationQueue addOperation:operation];
+    }else if(isSerial){
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_SERIAL, 0), ^{
+              task();
+          });
+        
+    }else {
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+              task();
+          });
+    }
 }
 
 - (NSOperationQueue*)getOperationQueue {
@@ -42,7 +75,7 @@
 
 @end
 
-NSOperationQueueWrapper::NSOperationQueueWrapper(bool currentQueue) {
+NSOperationQueueWrapper::NSOperationQueueWrapper(bool currentQueue, bool serial) {
     if (currentQueue) {
         NSOperationQueueWrapperObjC* objcWrapper = [[NSOperationQueueWrapperObjC alloc] initWithCurrentQueue];
         
@@ -50,11 +83,10 @@ NSOperationQueueWrapper::NSOperationQueueWrapper(bool currentQueue) {
     
         operationQueue = (void*)ptr;
     }else {
-        NSOperationQueueWrapperObjC* objcWrapper = [[NSOperationQueueWrapperObjC alloc] init];
+        NSOperationQueueWrapperObjC* objcWrapper = [[NSOperationQueueWrapperObjC alloc] initWithSerial: serial];
         CFTypeRef ptr = (__bridge_retained CFTypeRef)objcWrapper;
         operationQueue = (void*)ptr;
     }
-   
 }
 
 NSOperationQueueWrapper::~NSOperationQueueWrapper() {

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

@@ -19,6 +19,7 @@
 
 #include <unistd.h>
 #include <fcntl.h>
+#include <thread>
 
 typedef void(*CompleteCallback)(bool success, void *data);
 
@@ -45,14 +46,23 @@ struct AsyncCallback {
             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){
+                    if(callback->inner_->current_queue == nullptr){
                         return;
                     }
-                    inner->current_queue->addOperation([success, data, inner, callback](){
+                    
+                    auto inner = std::shared_ptr<Inner>(callback->inner_);
+                                        
+                    std::thread thread([success, data, callback](std::shared_ptr<Inner> inner){
+                        inner->current_queue = nullptr;
                         inner->completeCallback_(success, data);
-                       // delete callback;
-                    });
+                    }, std::move(inner));
+                    
+                    thread.detach();
+                    
+//                    callback->inner_->current_queue->addOperation([success, data, callback, inner_ptr](){
+//                        inner_ptr->completeCallback_(success, data);
+//                       // delete callback;
+//                    });
                 }
             };
         }
@@ -170,7 +180,7 @@ struct AsyncCallback {
         auto data = new AsyncCallback(this->inner_);
         ALooper_addFd(looper,
                       fd,
-                      ALOOPER_POLL_CALLBACK,
+                      0,
                       ALOOPER_EVENT_INPUT,
                       [](int fd, int events,
                          void *data) {
@@ -181,8 +191,6 @@ struct AsyncCallback {
                           cb->inner_->completeCallback_(done, data);
                           return 0;
                       }, (void *) data);
-
-        ALooper_wake(looper);
     }
 
     void execute(bool complete) const {

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

@@ -285,7 +285,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 
     if (image->IsNullOrUndefined()) {
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate, "Failed to load image"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
         return;
@@ -295,7 +295,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate,
                                                          "Failed to execute 'createImageBitmap' : The crop rect width is 0"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
 
@@ -304,7 +304,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
     if (len >= 5 && (sh->IsNumber() && sh->IsNumber() == 0)) {
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate,
                                                          "Failed to execute 'createImageBitmap' : The crop rect height is 0"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
         return;
@@ -338,16 +338,18 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 #ifdef __ANDROID__
                 ALooper_addFd(jsi_callback->looper_,
                               jsi_callback->fd_[0],
-                              ALOOPER_POLL_CALLBACK,
+                              0,
                               ALOOPER_EVENT_INPUT,
                               [](int fd, int events,
                                  void *data) {
+                                    if(data == nullptr){
+                                        return 1;
+                                    }
                                   auto cb = static_cast<JSICallback *>(data);
                                   bool done;
                                   read(fd, &done,
                                        sizeof(bool));
 
-
                                   v8::Isolate *isolate = cb->isolate_;
                                   v8::Locker locker(isolate);
                                   v8::Isolate::Scope isolate_scope(isolate);
@@ -372,23 +374,23 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                       args[1] = v8::Null(isolate);
                                   }
 
-
                                   callback->Call(context, context->Global(), 2, args);
 
                                   delete static_cast<JSICallback *>(data);
                                   return 0;
                               }, jsi_callback);
 
-                ALooper_wake(jsi_callback->looper_);
-
                 if (isArrayBuffer) {
+                    // converting to Uint8Array
                     auto arrayBuffer = imageObject.As<v8::ArrayBuffer>();
-                    auto store = arrayBuffer->GetBackingStore();
+                    auto size = arrayBuffer->ByteLength();
+                    imageObject = v8::Uint8Array::New(arrayBuffer, 0, size);
+                /*  auto store = arrayBuffer->GetBackingStore();
                     auto dataBuffer = (uint8_t *) store->Data();
-                    v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
+
                     std::thread thread(
-                            [&dataBuffer, jsi_callback, &options, store, shared_asset](
-                                    v8::Global<v8::ArrayBuffer> ab, size_t size) {
+                            [&dataBuffer, jsi_callback, &options, store, shared_asset, size](
+                                    v8::Global<v8::ArrayBuffer> ab) {
 
 
                                 auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
@@ -401,23 +403,24 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeHeight,
                                         shared_asset);
 
-                                canvas_native_image_asset_release(shared_asset);
-
                                 write(jsi_callback->fd_[1],
                                       &done,
                                       sizeof(bool));
 
+                                //  canvas_native_image_asset_release(shared_asset);
 
-                            }, std::move(ab), arrayBuffer->ByteLength());
+
+                            });
 
                     thread.detach();
                     return;
+
+                    */
                 }
 
 
                 auto ta = imageObject.As<v8::ArrayBufferView>();
 
-
                 auto array = ta->Buffer();
                 auto offset = ta->ByteOffset();
                 auto size = ta->ByteLength();
@@ -440,12 +443,12 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeHeight,
                                     shared_asset);
 
-                            canvas_native_image_asset_release(shared_asset);
-
                             write(jsi_callback->fd_[1],
                                   &done,
                                   sizeof(bool));
 
+                            //  canvas_native_image_asset_release(shared_asset);
+
 
                         }, std::move(ab));
                 thread.detach();
@@ -464,9 +467,74 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                     auto dataBuffer = (uint8_t *) store->Data();
                     v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
 
+                    auto size = arrayBuffer->ByteLength();
+
+
+                    auto thread_queue = new NSOperationQueueWrapper(false);
+
+
+                    thread_queue->addOperation([&dataBuffer, jsi_callback, &options, store, shared_asset, current_queue, &ab, size]() {
+
+                        auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
+                                                                                                     dataBuffer, size,
+                                                                                                     options.flipY,
+                                                                                                     options.premultiplyAlpha,
+                                                                                                     options.colorSpaceConversion,
+                                                                                                     options.resizeQuality,
+                                                                                                     options.resizeWidth,
+                                                                                                     options.resizeHeight,
+                                                                                                     shared_asset);
+
+
+
+                        auto main_task = [jsi_callback, current_queue, done, shared_asset]() {
+
+                            v8::Isolate *isolate = jsi_callback->isolate_;
+                            v8::Locker locker(isolate);
+                            v8::Isolate::Scope isolate_scope(isolate);
+                            v8::HandleScope handle_scope(isolate);
+                            v8::Local<v8::Function> callback = jsi_callback->callback_->Get(isolate);
+                            v8::Local<v8::External> cbData = jsi_callback->data_->Get(
+                                                                                      isolate).As<v8::External>();
+                            v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                            v8::Context::Scope context_scope(context);
+
+                            auto ret = ImageBitmapImpl::NewInstance(isolate, cbData);
+
+                            v8::Local<v8::Value> args[2];
+
+                            if (done) {
+                                args[0] = v8::Null(isolate);
+                                args[1] = ret;
+
+                            } else {
+                                args[0] = v8::Exception::Error(
+                                                               ConvertToV8String(isolate, "Failed to load image"));
+                                args[1] = v8::Null(isolate);
+                            }
+
+
+                            callback->Call(context, context->Global(), 2, args);
+
+                            delete jsi_callback;
+                            delete current_queue;
+
+                            canvas_native_image_asset_release(shared_asset);
+
+                        };
+                        current_queue->addOperation(main_task);
+
+                    });
+
+
+
+
+
+
+                    /*
                     std::thread thread(
-                            [&dataBuffer, jsi_callback, &options, store, shared_asset, current_queue](
-                                    v8::Global<v8::ArrayBuffer> ab, size_t size
+                            [&dataBuffer, jsi_callback, &options, store, &shared_asset, current_queue, size](
+                                    v8::Global<v8::ArrayBuffer> ab
                             ) {
 
                                 auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
@@ -479,10 +547,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeHeight,
                                         shared_asset);
 
-                                canvas_native_image_asset_release(shared_asset);
-
-
-                                auto main_task = [jsi_callback, current_queue, done]() {
+                                auto main_task = [jsi_callback, current_queue, done, shared_asset]() {
 
 
                                     v8::Isolate *isolate = jsi_callback->isolate_;
@@ -516,12 +581,17 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     delete jsi_callback;
                                     delete current_queue;
 
+                                    canvas_native_image_asset_release(shared_asset);
+
                                 };
                                 current_queue->addOperation(main_task);
 
-                            }, std::move(ab), arrayBuffer->ByteLength());
+                            }, std::move(ab));
 
-                    thread.detach();
+                   thread.detach();
+
+
+                    */
 
                     return;
                 }
@@ -553,9 +623,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeHeight,
                                     shared_asset);
 
-                            canvas_native_image_asset_release(shared_asset);
 
-                            auto main_task = [jsi_callback, current_queue, done]() {
+                            auto main_task = [jsi_callback, current_queue, done, shared_asset]() {
 
 
                                 v8::Isolate *isolate = jsi_callback->isolate_;
@@ -587,6 +656,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                 delete jsi_callback;
                                 delete current_queue;
 
+                                canvas_native_image_asset_release(shared_asset);
+
                             };
                             current_queue->addOperation(main_task);
 
@@ -617,7 +688,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 #ifdef __ANDROID__
                 ALooper_addFd(jsi_callback->looper_,
                               jsi_callback->fd_[0],
-                              ALOOPER_POLL_CALLBACK,
+                              0,
                               ALOOPER_EVENT_INPUT,
                               [](int fd, int events,
                                  void *data) {
@@ -655,11 +726,13 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                   return 0;
                               }, jsi_callback);
 
-                ALooper_wake(jsi_callback->looper_);
-
                 auto bufferValue = args[0];
 
                 if (isArrayBuffer) {
+                    auto arrayBuffer = bufferValue.As<v8::ArrayBuffer>();
+                    auto size = arrayBuffer->ByteLength();
+                    imageObject = v8::Uint8Array::New(arrayBuffer, 0, size);
+                    /*
                     auto arrayBuffer = bufferValue.As<v8::ArrayBuffer>();
                     auto dataBuffer = (uint8_t *) arrayBuffer->GetBackingStore()->Data();
                     v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
@@ -686,13 +759,12 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeWidth,
                                         options.resizeHeight, shared_asset);
 
-                                canvas_native_image_asset_release(shared_asset);
-
-
                                 write(jsi_callback->fd_[1],
                                       &done,
                                       sizeof(bool));
 
+                                canvas_native_image_asset_release(shared_asset);
+
                             },
                             (float) sx_or_options->NumberValue(context).ToChecked(),
                             (float) sy->NumberValue(context).ToChecked(),
@@ -703,6 +775,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                     thread.detach();
 
                     return;
+                    */
                 }
 
                 auto ta = bufferValue.As<v8::ArrayBufferView>();
@@ -736,13 +809,13 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeWidth,
                                     options.resizeHeight, shared_asset);
 
-                            canvas_native_image_asset_release(shared_asset);
-
 
                             write(jsi_callback->fd_[1],
                                   &done,
                                   sizeof(bool));
 
+                            canvas_native_image_asset_release(shared_asset);
+
                         },
                         (float) sx_or_options->NumberValue(context).ToChecked(),
                         (float) sy->NumberValue(context).ToChecked(),
@@ -786,10 +859,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                         options.resizeWidth,
                                         options.resizeHeight, shared_asset);
 
-                                canvas_native_image_asset_release(shared_asset);
-
 
-                                auto main_task = [jsi_callback, current_queue, done]() {
+                                auto main_task = [jsi_callback, current_queue, done,shared_asset]() {
 
 
                                     v8::Isolate *isolate = jsi_callback->isolate_;
@@ -823,6 +894,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     delete jsi_callback;
                                     delete current_queue;
 
+                                    canvas_native_image_asset_release(shared_asset);
+
                                 };
                                 current_queue->addOperation(main_task);
 
@@ -871,9 +944,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                     options.resizeWidth,
                                     options.resizeHeight, shared_asset);
 
-                            canvas_native_image_asset_release(shared_asset);
 
-                            auto main_task = [jsi_callback, current_queue, done]() {
+                            auto main_task = [jsi_callback, current_queue, done, shared_asset]() {
 
 
                                 v8::Isolate *isolate = jsi_callback->isolate_;
@@ -905,6 +977,8 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                                 delete jsi_callback;
                                 delete current_queue;
 
+                                canvas_native_image_asset_release(shared_asset);
+
                             };
                             current_queue->addOperation(main_task);
 
@@ -1080,7 +1154,7 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
 #ifdef __ANDROID__
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -1165,8 +1239,6 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
     std::thread thread(
             [jsi_callback](const std::string &file) {
                 bool done = false;

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

@@ -11,7 +11,7 @@
 #include "Helpers.h"
 #include "Common.h"
 
-ImageAssetImpl::ImageAssetImpl(ImageAsset *asset) : asset_(asset) {
+ImageAssetImpl::ImageAssetImpl(const ImageAsset *asset) : asset_(asset) {
 }
 
 ImageAssetImpl::~ImageAssetImpl() {
@@ -240,7 +240,7 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -269,8 +269,6 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
 
     std::thread thread(
             [jsi_callback, asset](
@@ -412,19 +410,17 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     auto path = ConvertFromV8String(isolate, args[0]);
 
-    auto asset = canvas_native_image_asset_reference(
-            ptr->GetImageAsset());
+    auto asset = canvas_native_image_asset_reference(ptr->GetImageAsset());
 
     auto callback = args[1].As<v8::Function>();
 
-
     auto jsi_callback = new JSICallback(isolate, callback);
 
 #ifdef __ANDROID__
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -443,7 +439,7 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
                       v8::Local<v8::Value> args[1] = {v8::Boolean::New(isolate, done)};
 
-                      // v8::TryCatch tc(isolate);
+                       v8::TryCatch tc(isolate);
 
                       callback->Call(context, context->Global(), 1,
                                      args);  // ignore JS return value
@@ -452,23 +448,23 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
 
     std::thread thread(
             [jsi_callback, asset](
-                    const std::string &path) {
+                    const std::string path) {
 
                 auto done = canvas_native_image_asset_load_from_path(asset, path.c_str());
 
-                canvas_native_image_asset_release(asset);
-
                 write(jsi_callback->fd_[1],
                       &done,
                       sizeof(bool));
 
+                canvas_native_image_asset_release(asset);
+
             }, std::move(path));
 
+    thread.detach();
+
 #endif
 
 
@@ -481,7 +477,7 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
     auto task = [jsi_callback, current_queue, queue, asset, path]() {
 
         auto done = canvas_native_image_asset_load_from_path(asset, path.c_str());
-
+        
         canvas_native_image_asset_release(asset);
 
         auto main_task = [jsi_callback, current_queue, queue, done]() {
@@ -514,6 +510,8 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
     };
 
     queue->addOperation(task);
+    
+
 #endif
 }
 
@@ -572,7 +570,7 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -600,9 +598,6 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
-
     std::thread thread(
             [jsi_callback, asset, data, size]() {
 
@@ -713,7 +708,7 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -741,9 +736,6 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
-
     std::thread thread(
             [jsi_callback, asset, format](
                     const std::string &path) {
@@ -813,7 +805,7 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
 }
 */
 
-ImageAsset *ImageAssetImpl::GetImageAsset() {
+const ImageAsset *ImageAssetImpl::GetImageAsset() {
     return this->asset_;
 }