fix: switch to callAsync for CallInvoker

Author: JakubGonera

common/rnexecutorch/host_objects/JsiConversions.h

@@ -70,8 +70,7 @@ getValue<std::set<std::string, std::less<>>>(const jsi::Value &val,
 // return jsi::Value or jsi::Object. For each type being returned
 // we add a function here.
 
-// Identity function for the sake of completeness
-inline jsi::Value getJsiValue(std::unique_ptr<jsi::Object> &&valuePtr,
+inline jsi::Value getJsiValue(std::shared_ptr<jsi::Object> valuePtr,
                               jsi::Runtime &runtime) {
   return std::move(*valuePtr);
 }

common/rnexecutorch/host_objects/ModelHostObject.h

@@ -48,11 +48,12 @@ template <typename Model> class ModelHostObject : public JsiHostObject {
             std::thread([this, promise,
                          argsConverted = std::move(argsConverted)]() {
               try {
+
                 auto result = std::apply(
                     std::bind_front(&Model::forward, model), argsConverted);
 
-                callInvoker->invokeSync([promise,
-                                         &result](jsi::Runtime &runtime) {
+                callInvoker->invokeAsync([promise,
+                                          result](jsi::Runtime &runtime) {
                   promise->resolve(
                       jsiconversion::getJsiValue(std::move(result), runtime));
                 });

common/rnexecutorch/models/image_segmentation/ImageSegmentation.cpp

@@ -1,5 +1,7 @@
 #include "ImageSegmentation.h"
 
+#include <future>
+
 #include <executorch/extension/tensor/tensor.h>
 
 #include <rnexecutorch/data_processing/ImageProcessing.h>
@@ -20,7 +22,7 @@ ImageSegmentation::ImageSegmentation(
   numModelPixels = modelImageSize.area();
 }
 
-std::unique_ptr<jsi::Object>
+std::shared_ptr<jsi::Object>
 ImageSegmentation::forward(std::string imageSource,
                            std::set<std::string, std::less<>> classesOfInterest,
                            bool resize) {
@@ -50,7 +52,7 @@ ImageSegmentation::preprocess(const std::string &imageSource) {
       inputSize};
 }
 
-std::unique_ptr<jsi::Object> ImageSegmentation::postprocess(
+std::shared_ptr<jsi::Object> ImageSegmentation::postprocess(
     const Tensor &tensor, cv::Size originalSize,
     std::set<std::string, std::less<>> classesOfInterest, bool resize) {
 
@@ -128,16 +130,21 @@ std::unique_ptr<jsi::Object> ImageSegmentation::postprocess(
   return populateDictionary(argmax, buffersToReturn);
 }
 
-std::unique_ptr<jsi::Object> ImageSegmentation::populateDictionary(
+std::shared_ptr<jsi::Object> ImageSegmentation::populateDictionary(
     std::shared_ptr<OwningArrayBuffer> argmax,
     std::shared_ptr<std::unordered_map<std::string_view,
                                        std::shared_ptr<OwningArrayBuffer>>>
         classesToOutput) {
-  std::unique_ptr<jsi::Object> dictPtr;
+  // Synchronize the invoked thread to return when the dict is constructed
+  auto promisePtr = std::make_shared<std::promise<void>>();
+  std::future<void> doneFuture = promisePtr->get_future();
+
+  log(LOG_LEVEL::Debug, "To sie po prostu w pale nie miesci!");
 
-  callInvoker->invokeSync(
-      [argmax, classesToOutput, &dictPtr](jsi::Runtime &runtime) {
-        dictPtr = std::make_unique<jsi::Object>(runtime);
+  std::shared_ptr<jsi::Object> dictPtr = nullptr;
+  callInvoker->invokeAsync(
+      [argmax, classesToOutput, &dictPtr, promisePtr](jsi::Runtime &runtime) {
+        dictPtr = std::make_shared<jsi::Object>(runtime);
         auto argmaxArrayBuffer = jsi::ArrayBuffer(runtime, argmax);
 
         auto int32ArrayCtor =
@@ -160,8 +167,10 @@ std::unique_ptr<jsi::Object> ImageSegmentation::populateDictionary(
               runtime, jsi::String::createFromAscii(runtime, classLabel.data()),
               float32Array);
         }
+        promisePtr->set_value();
       });
 
+  doneFuture.wait();
   return dictPtr;
 }
 

common/rnexecutorch/models/image_segmentation/ImageSegmentation.h

@@ -21,17 +21,17 @@ class ImageSegmentation : public BaseModel {
 public:
   ImageSegmentation(const std::string &modelSource,
                     std::shared_ptr<react::CallInvoker> callInvoker);
-  std::unique_ptr<jsi::Object>
+  std::shared_ptr<jsi::Object>
   forward(std::string imageSource,
           std::set<std::string, std::less<>> classesOfInterest, bool resize);
 
 private:
   std::pair<TensorPtr, cv::Size> preprocess(const std::string &imageSource);
-  std::unique_ptr<jsi::Object>
+  std::shared_ptr<jsi::Object>
   postprocess(const Tensor &tensor, cv::Size originalSize,
               std::set<std::string, std::less<>> classesOfInterest,
               bool resize);
-  std::unique_ptr<jsi::Object> populateDictionary(
+  std::shared_ptr<jsi::Object> populateDictionary(
       std::shared_ptr<OwningArrayBuffer> argmax,
       std::shared_ptr<std::unordered_map<std::string_view,
                                          std::shared_ptr<OwningArrayBuffer>>>

examples/computer-vision/screens/ImageSegmentationScreen.tsx

@@ -4,6 +4,7 @@ import { getImage } from '../utils';
 import {
   useImageSegmentation,
   DEEPLAB_V3_RESNET50,
+  DeeplabLabel,
 } from 'react-native-executorch';
 import {
   Canvas,
@@ -79,14 +80,16 @@ export const ImageSegmentationScreen = ({
   const runForward = async () => {
     if (imageUri) {
       try {
-        const output = await model.forward(imageUri, [], false);
+        const output = await model.forward(imageUri);
         pixels = new Uint8Array(width * height * 4);
 
         for (let x = 0; x < width; x++) {
           for (let y = 0; y < height; y++) {
             for (let i = 0; i < 3; i++) {
               pixels[(x * height + y) * 4 + i] =
-                numberToColor[(output['ARGMAX'] || [])[x * height + y]][i];
+                numberToColor[
+                  (output[DeeplabLabel.ARGMAX] || [])[x * height + y]
+                ][i];
             }
             pixels[(x * height + y) * 4 + 3] = 255;
           }