@shopify/react-native-skia 0.1.121 → 0.1.124

package/cpp/rnskia/RNSkAnimation.h

@@ -15,7 +15,7 @@ using namespace facebook;
 /**
  Implements an animation that can be used to drive other values
  */
-class RNSkAnimation : public RNSkClockValue, public std::enable_shared_from_this<RNSkAnimation>
+class RNSkAnimation : public RNSkClockValue
 {
   
 public:
@@ -23,8 +23,8 @@ public:
                      size_t identifier,
                      jsi::Runtime& runtime,
                      const jsi::Value *arguments,
-                     size_t count)
-      : RNSkClockValue(platformContext, identifier, runtime, arguments, count) {
+                     size_t count) :
+    RNSkClockValue(platformContext, identifier, runtime, arguments, count) {
     // Save the update function
     _updateFunction = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
         
@@ -32,11 +32,6 @@ public:
     _args[1] = jsi::Value::undefined();
   }
   
-  ~RNSkAnimation() {
-    // We need to stop/unsubscribe
-    stopClock();
-  }
-  
   JSI_HOST_FUNCTION(cancel) {
     stopClock();
     return jsi::Value::undefined();

package/cpp/rnskia/RNSkDrawView.cpp

@@ -40,31 +40,13 @@ RNSkDrawView::RNSkDrawView(std::shared_ptr<RNSkPlatformContext> context)
       _platformContext(std::move(context)),
       _infoObject(std::make_shared<RNSkInfoObject>()),
       _jsDrawingLock(std::make_shared<std::timed_mutex>()),
-      _gpuDrawingLock(std::make_shared<std::timed_mutex>())
+      _gpuDrawingLock(std::make_shared<std::timed_mutex>()),
+      _jsTimingInfo("SKIA/JS"),
+      _gpuTimingInfo("SKIA/GPU")
       {}
 
 RNSkDrawView::~RNSkDrawView() {
-#if LOG_ALL_DRAWING
-  RNSkLogger::logToConsole("RNSkDrawView::~RNSkDrawView - %i", getNativeId());
-#endif
-  
-  _isInvalidated = true;
-  
   endDrawingLoop();
-  
-  // Wait for the drawing locks
-  if(!_jsDrawingLock->try_lock_for(1250ms)) {
-    RNSkLogger::logToConsole("Warning: JS drawing is still locked for native view with id %i", _nativeId);
-  }
-  
-  if(!_gpuDrawingLock->try_lock_for(1250ms)) {
-    RNSkLogger::logToConsole("Warning: SKIA drawing is still locked for native view with id %i", _nativeId);
-  }
-  
-  onInvalidated();
-
-  _jsDrawingLock = nullptr;
-  _gpuDrawingLock = nullptr;
 }
 
 void RNSkDrawView::setNativeId(size_t nativeId) {
@@ -84,63 +66,63 @@ void RNSkDrawView::setDrawCallback(std::shared_ptr<jsi::Function> callback) {
   // Reset timing info
   _jsTimingInfo.reset();
   _gpuTimingInfo.reset();
-  _vsyncTimingInfo.reset();
-  
-  // Set up debug font/paints
-  auto font = SkFont();
-  font.setSize(14);
-  auto paint = SkPaint();
-  paint.setColor(SkColors::kRed);
   
   // Create draw drawCallback wrapper
   _drawCallback = std::make_shared<RNSkDrawCallback>(
-      [this, paint = std::move(paint), font = std::move(font), callback = std::move(callback)](std::shared_ptr<JsiSkCanvas> canvas, int width,
-                                    int height, double timestamp,
-                                    std::shared_ptr<RNSkPlatformContext> context) {
-
-       auto runtime = context->getJsRuntime();
-                         
-       // Update info parameter
-       _infoObject->beginDrawOperation(width, height, timestamp);
-       
-       // Set up arguments array
-       std::vector<jsi::Value> args(2);
-       args[0] = jsi::Object::createFromHostObject(*runtime, canvas);
-       args[1] = jsi::Object::createFromHostObject(*runtime, _infoObject);
-
-       // To be able to call the drawing function we'll wrap it once again
-       callback->call(*runtime,
-                      static_cast<const jsi::Value *>(args.data()),
-                      (size_t)2);
-       
-       // Reset touches
-       _infoObject->endDrawOperation();
-                         
-      // Draw debug overlays
-      if (_showDebugOverlay) {
-
-        // Display average rendering timer
-        auto jsAvg = _jsTimingInfo.getAverage();
-        //auto jsFps = _jsTimingInfo.getFps();
-        
-        auto gpuAvg = _gpuTimingInfo.getAverage();
-        //auto gpuFps = _gpuTimingInfo.getFps();
-        
-        auto total = jsAvg + gpuAvg;
-        
-        //auto vsyncFps = _vsyncTimingInfo.getFps();
-                                                      
-        // Build string
-        std::ostringstream stream;
-        stream << "js: " << jsAvg << "ms gpu: " << gpuAvg << "ms " << " total: " << total << "ms";
-//        stream << "js:" << jsAvg << "ms/" << jsFps << "fps " << "gpu:" << gpuAvg << "ms/" <<
-//          gpuFps << "fps" << " total:" << total << "ms/" << vsyncFps << "fps";
-        
-        std::string debugString = stream.str();
-        
-        canvas->getCanvas()->drawSimpleText(
-         debugString.c_str(), debugString.size(), SkTextEncoding::kUTF8, 8,
-         18, font, paint);
+      [weakSelf = weak_from_this(),
+       callback = std::move(callback)](std::shared_ptr<JsiSkCanvas> canvas,
+                                       int width,
+                                       int height,
+                                       double timestamp,
+                                       std::shared_ptr<RNSkPlatformContext> context) {
+
+       auto self = weakSelf.lock();
+       if(self) {
+         auto runtime = context->getJsRuntime();
+                           
+         // Update info parameter
+         self->_infoObject->beginDrawOperation(width, height, timestamp);
+         
+         // Set up arguments array
+         std::vector<jsi::Value> args(2);
+         args[0] = jsi::Object::createFromHostObject(*runtime, canvas);
+         args[1] = jsi::Object::createFromHostObject(*runtime, self->_infoObject);
+
+         // To be able to call the drawing function we'll wrap it once again
+         callback->call(*runtime,
+                        static_cast<const jsi::Value *>(args.data()),
+                        (size_t)2);
+         
+         // Reset touches
+         self->_infoObject->endDrawOperation();
+                           
+        // Draw debug overlays
+        if (self->_showDebugOverlay) {
+
+          // Display average rendering timer
+          auto jsAvg = self->_jsTimingInfo.getAverage();
+          //auto jsFps = _jsTimingInfo.getFps();
+          
+          auto gpuAvg = self->_gpuTimingInfo.getAverage();
+          //auto gpuFps = _gpuTimingInfo.getFps();
+          
+          auto total = jsAvg + gpuAvg;
+          
+          // Build string
+          std::ostringstream stream;
+          stream << "js: " << jsAvg << "ms gpu: " << gpuAvg << "ms " << " total: " << total << "ms";
+          
+          std::string debugString = stream.str();
+
+          // Set up debug font/paints
+          auto font = SkFont();
+          font.setSize(14);
+          auto paint = SkPaint();
+          paint.setColor(SkColors::kRed);
+          canvas->getCanvas()->drawSimpleText(
+           debugString.c_str(), debugString.size(), SkTextEncoding::kUTF8, 8,
+           18, font, paint);
+        }
       }
     });
 
@@ -172,7 +154,7 @@ void RNSkDrawView::drawInCanvas(std::shared_ptr<JsiSkCanvas> canvas,
 
 sk_sp<SkImage> RNSkDrawView::makeImageSnapshot(std::shared_ptr<SkRect> bounds) {
   // Assert width/height
-  auto surface = SkSurface::MakeRasterN32Premul(getWidth(), getHeight());
+  auto surface = SkSurface::MakeRasterN32Premul(getScaledWidth(), getScaledHeight());
   auto canvas = surface->getCanvas();
   auto jsiCanvas = std::make_shared<JsiSkCanvas>(_platformContext);
   jsiCanvas->setCanvas(canvas);
@@ -180,7 +162,7 @@ sk_sp<SkImage> RNSkDrawView::makeImageSnapshot(std::shared_ptr<SkRect> bounds) {
   milliseconds ms = duration_cast<milliseconds>(
       system_clock::now().time_since_epoch());
   
-  drawInCanvas(jsiCanvas, getWidth(), getHeight(), ms.count() / 1000);
+  drawInCanvas(jsiCanvas, getScaledWidth(), getScaledHeight(), ms.count() / 1000);
   
   if(bounds != nullptr) {
     SkIRect b = SkIRect::MakeXYWH(bounds->x(), bounds->y(), bounds->width(), bounds->height());
@@ -196,10 +178,6 @@ void RNSkDrawView::updateTouchState(std::vector<RNSkTouchPoint>&& points) {
 }
 
 void RNSkDrawView::performDraw() {
-#if LOG_ALL_DRAWING
-  RNSkLogger::logToConsole("RNSkDrawView::performDraw - %i", getNativeId());
-#endif
-  
   // Start timing
   _jsTimingInfo.beginTiming();
   
@@ -207,7 +185,7 @@ void RNSkDrawView::performDraw() {
   // move the actual drawing onto the render thread later
   SkPictureRecorder recorder;
   SkRTreeFactory factory;
-  SkCanvas* canvas = recorder.beginRecording(getWidth(), getHeight(), &factory);
+  SkCanvas* canvas = recorder.beginRecording(getScaledWidth(), getScaledHeight(), &factory);
   _jsiCanvas->setCanvas(canvas);
   
   // Get current milliseconds
@@ -216,7 +194,7 @@ void RNSkDrawView::performDraw() {
   
   try {
     // Perform the javascript drawing
-    drawInCanvas(_jsiCanvas, getWidth(), getHeight(), ms.count() / 1000.0);
+    drawInCanvas(_jsiCanvas, getScaledWidth(), getScaledHeight(), ms.count() / 1000.0);
   } catch(...) {
     _jsTimingInfo.stopTiming();
     _jsDrawingLock->unlock();
@@ -234,37 +212,22 @@ void RNSkDrawView::performDraw() {
     // Post drawing message to the render thread where the picture recorded
     // will be sent to the GPU/backend for rendering to screen.
     auto gpuLock = _gpuDrawingLock;
-    getPlatformContext()->runOnRenderThread([this, p = std::move(p), gpuLock]() {
-      
-      if(isInvalidated()) {
-        gpuLock->unlock();
-        return;
+    _platformContext->runOnRenderThread([weakSelf = weak_from_this(), p = std::move(p), gpuLock]() {
+      auto self = weakSelf.lock();
+      if (self) {
+        // Draw the picture recorded on the real GPU canvas
+        self->_gpuTimingInfo.beginTiming();
+        self->drawPicture(p);
+        self->_gpuTimingInfo.stopTiming();
       }
-      
-      _gpuTimingInfo.beginTiming();
-
-      // Draw the picture recorded on the real GPU canvas
-      if(_nativeDrawFunc != nullptr) {
-#if LOG_ALL_DRAWING
-          RNSkLogger::logToConsole("RNSkDrawView::drawFrame - %i", getNativeId());
-#endif
-        _nativeDrawFunc(p);
-      } else {
-#if LOG_ALL_DRAWING
-          RNSkLogger::logToConsole("RNSkDrawView::drawFrame - %i SKIPPING, draw func is null", getNativeId());
-#endif
-      }
-
-      _gpuTimingInfo.stopTiming();
-
       // Unlock GPU drawing
       gpuLock->unlock();
     });
   } else {
 #ifdef DEBUG
-    static size_t framesSkipped = 0;
-    printf("SKIA/GPU: Skipped frames: %lu\n", ++framesSkipped);
+    _gpuTimingInfo.markSkipped();
 #endif
+    // Request a new redraw since the last frame was skipped.
     requestRedraw();
   }
   
@@ -280,39 +243,34 @@ void RNSkDrawView::beginDrawingLoop() {
   if (_drawingLoopId != 0 || _nativeId == 0) {
     return;
   }
-  
   // Set to zero to avoid calling beginDrawLoop before we return
-  _drawingLoopId = _platformContext->beginDrawLoop(
-    _nativeId, std::bind(&RNSkDrawView::drawLoopCallback, this, std::placeholders::_1));
+  _drawingLoopId = _platformContext->beginDrawLoop(_nativeId,
+    [weakSelf = weak_from_this()](bool invalidated) {
+    auto self = weakSelf.lock();
+    if(self) {
+      self->drawLoopCallback(invalidated);
+    }
+  });
 }
 
 void RNSkDrawView::drawLoopCallback(bool invalidated) {
-  if(invalidated) {
-    _isInvalidated = true;
-    onInvalidated();
-#if LOG_ALL_DRAWING
-  RNSkLogger::logToConsole("RNSkDrawView::onInvalidated - %i", getNativeId());
-#endif
-    return;
-  }
-  
   if(_redrawRequestCounter > 0 || _drawingMode == RNSkDrawingMode::Continuous) {
       _redrawRequestCounter = 0;
       
-    _vsyncTimingInfo.beginTiming();
-    
     // We render on the javascript thread.
     if(_jsDrawingLock->try_lock()) {
-      _platformContext->runOnJavascriptThread(std::bind(&RNSkDrawView::performDraw, this));
+      _platformContext->runOnJavascriptThread([weakSelf = weak_from_this()](){
+        auto self = weakSelf.lock();
+        if(self) {
+          self->performDraw();
+        }
+      });
     } else {
 #ifdef DEBUG
-      static size_t framesSkipped = 0;
-      printf("SKIA/JS: Skipped frames: %lu\n", ++framesSkipped);
+      _jsTimingInfo.markSkipped();
 #endif
       requestRedraw();
     }
-    
-    _vsyncTimingInfo.stopTiming();
   }
 }
 

package/cpp/rnskia/RNSkDrawView.h

@@ -20,8 +20,6 @@
 
 #pragma clang diagnostic pop
 
-#define LOG_ALL_DRAWING 0
-
 class SkPicture;
 class SkRect;
 class SkImage;
@@ -35,7 +33,7 @@ using RNSkDrawCallback =
 
 enum RNSkDrawingMode { Default, Continuous };
 
-class RNSkDrawView {
+class RNSkDrawView: public std::enable_shared_from_this<RNSkDrawView> {
 public:
   /**
    * Constructor
@@ -45,7 +43,7 @@ public:
   /**
    Destructor
    */
-  ~RNSkDrawView();
+  virtual ~RNSkDrawView();
 
   /**
    * Repaints the Skia view using the underlying context and the drawcallback.
@@ -96,33 +94,20 @@ public:
   sk_sp<SkImage> makeImageSnapshot(std::shared_ptr<SkRect> bounds);
 
 protected:
-  void setNativeDrawFunc(std::function<void(const sk_sp<SkPicture>)> drawFunc) {
-    if(!_gpuDrawingLock->try_lock_for(250ms)) {
-      RNSkLogger::logToConsole("Could not lock drawing when clearing drawing function - %i", _nativeId);
-    }
-    _nativeDrawFunc = drawFunc;
-    _gpuDrawingLock->unlock();
-  }
-  
   /**
    Returns the scaled width of the view
    */
-  virtual int getWidth() { return -1; };
+  virtual float getScaledWidth() = 0;
   
   /**
    Returns the scaled height of the view
    */
-  virtual int getHeight() { return -1; };
-  
-  /**
-   Returns true if the view is invalidated
-   */
-  volatile bool isInvalidated() { return _isInvalidated; }
+  virtual float getScaledHeight() = 0;
   
   /**
-   Override to be notified on invalidation
+   Override to render picture to GPU
    */
-  virtual void onInvalidated() {}
+  virtual void drawPicture(const sk_sp<SkPicture> picture) = 0;
   
   /**
    * @return The platformcontext
@@ -210,12 +195,7 @@ private:
   /**
    Timing information for GPU rendering
    */
-  RNSkTimingInfo _gpuTimingInfo;
-  
-  /**
-   Measures vsync framerate
-   */
-  RNSkTimingInfo _vsyncTimingInfo;
+  RNSkTimingInfo _gpuTimingInfo;  
   
   /**
    Redraw queue counter
@@ -227,16 +207,6 @@ private:
    */
   size_t _nativeId;
   
-  /**
-   Invalidation flag
-   */
-  std::atomic<bool> _isInvalidated = { false };
-  
-  /**
-   Native draw handler
-   */
-  std::function<void(const sk_sp<SkPicture>)> _nativeDrawFunc;  
-  
 };
 
 } // namespace RNSkia

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -20,7 +20,7 @@ using CallbackInfo = struct CallbackInfo {
     view = nullptr;
   }
   std::shared_ptr<jsi::Function> drawCallback;
-  RNSkDrawView *view;
+  std::shared_ptr<RNSkDrawView> view;
 };
 
 class RNSkJsiViewApi : public JsiHostObject {
@@ -105,7 +105,7 @@ public:
     sk_sp<SkImage> image;
     auto info = getEnsuredCallbackInfo(nativeId);
     if (info->view != nullptr) {
-      if(count > 1 && !arguments[1].isUndefined() && arguments[1].isNull()) {
+      if(count > 1 && !arguments[1].isUndefined() && !arguments[1].isNull()) {
         auto rect = JsiSkRect::fromValue(runtime, arguments[1]);
         image = info->view->makeImageSnapshot(rect);
       } else {
@@ -226,7 +226,7 @@ public:
    * @param nativeId Id of view to register
    * @param view View to register
    */
-  void registerSkiaDrawView(size_t nativeId, RNSkDrawView *view) {
+  void registerSkiaDrawView(size_t nativeId, std::shared_ptr<RNSkDrawView> view) {
     auto info = getEnsuredCallbackInfo(nativeId);
     info->view = view;
     if (info->drawCallback != nullptr) {
@@ -260,15 +260,18 @@ public:
    a valid view is set, the setDrawCallback method is called on the
    view (if a valid callback exists).
    */
-  void setSkiaDrawView(size_t nativeId, RNSkDrawView *view) {
+  void setSkiaDrawView(size_t nativeId, std::shared_ptr<RNSkDrawView> view) {
     if (_callbackInfos.find(nativeId) == _callbackInfos.end()) {
       return;
     }
     auto info = getEnsuredCallbackInfo(nativeId);
-    info->view = view;
     if (view != nullptr && info->drawCallback != nullptr) {
+      info->view = view;
       info->view->setNativeId(nativeId);
       info->view->setDrawCallback(info->drawCallback);
+    } else if(view == nullptr && info->drawCallback != nullptr) {
+      info->view->setDrawCallback(nullptr);
+      info->view = view;
     }
   }
 

package/cpp/rnskia/RNSkManager.cpp

@@ -45,7 +45,7 @@ void RNSkManager::invalidate() {
   _platformContext->invalidate();
 }
 
-void RNSkManager::registerSkiaDrawView(size_t nativeId, RNSkDrawView *view) {
+void RNSkManager::registerSkiaDrawView(size_t nativeId, std::shared_ptr<RNSkDrawView> view) {
   if (!_isInvalidated && _viewApi != nullptr)
     _viewApi->registerSkiaDrawView(nativeId, view);
 }
@@ -55,7 +55,7 @@ void RNSkManager::unregisterSkiaDrawView(size_t nativeId) {
     _viewApi->unregisterSkiaDrawView(nativeId);
 }
 
-void RNSkManager::setSkiaDrawView(size_t nativeId, RNSkDrawView *view) {
+void RNSkManager::setSkiaDrawView(size_t nativeId, std::shared_ptr<RNSkDrawView> view) {
   if (!_isInvalidated && _viewApi != nullptr)
     _viewApi->setSkiaDrawView(nativeId, view);
 }

package/cpp/rnskia/RNSkManager.h

@@ -41,7 +41,7 @@ public:
    * @param nativeId Native view id
    * @param view View to register
    */
-  void registerSkiaDrawView(size_t nativeId, RNSkDrawView *view);
+  void registerSkiaDrawView(size_t nativeId, std::shared_ptr<RNSkDrawView> view);
 
   /**
    * Unregisters the RNSkDrawView from the list of registered views
@@ -54,7 +54,7 @@ public:
    Used when we want to remove a view without unregistering it
    - this happens typically on iOS.
    */
-  void setSkiaDrawView(size_t nativeId, RNSkDrawView *view);
+  void setSkiaDrawView(size_t nativeId, std::shared_ptr<RNSkDrawView> view);
 
   /**
    * @return The platform context

package/cpp/rnskia/RNSkPlatformContext.h

@@ -43,7 +43,7 @@ public:
   /**
    * Destructor
    */
-  ~RNSkPlatformContext() {
+  virtual ~RNSkPlatformContext() {
     invalidate();
   }
   

package/cpp/rnskia/RNSkValueApi.h

@@ -34,8 +34,12 @@ public:
   }
   
   JSI_HOST_FUNCTION(createDerivedValue) {
-    return jsi::Object::createFromHostObject(runtime,
-      std::make_shared<RNSkDerivedValue>(_platformContext, runtime, arguments, count));
+    // Creation and initialization is done in two steps to be able to use weak references when setting
+    // up dependencies - since weak_from_this needs our instance to be a shared_ptr before calling
+    // weak_from_this().
+    auto derivedValue = std::make_shared<RNSkDerivedValue>(_platformContext, runtime, arguments, count);
+    derivedValue->initializeDependencies(runtime, arguments, count);
+    return jsi::Object::createFromHostObject(runtime, derivedValue);
   }
   
   JSI_HOST_FUNCTION(createAnimation) {

package/cpp/rnskia/values/RNSkClockValue.h

@@ -8,7 +8,6 @@
 #include <algorithm>
 #include <functional>
 #include <chrono>
-#include <mutex>
 
 namespace RNSkia
 {
@@ -33,12 +32,11 @@ public:
                  size_t count) : RNSkReadonlyValue(platformContext),
         _runtime(runtime),
         _identifier(identifier) {
-    
     // Start by updating to zero (start value)
     update(_runtime, static_cast<double>(0));
   }
   
-  ~RNSkClockValue() {
+  virtual ~RNSkClockValue() {
     stopClock();
   }
   
@@ -73,8 +71,13 @@ public:
     _start += timeSinceStop;
     
     _state = RNSkClockState::Running;
-    auto dispatch = std::bind(&RNSkClockValue::notifyUpdate, this, std::placeholders::_1);
-    getContext()->beginDrawLoop(_identifier, dispatch);
+    
+    getContext()->beginDrawLoop(_identifier, [weakSelf = weak_from_this()](bool invalidated){
+      auto self = weakSelf.lock();
+      if(self) {
+        std::dynamic_pointer_cast<RNSkClockValue>(self)->notifyUpdate(invalidated);
+      }
+    });
   }
   
   virtual void stopClock() {
@@ -100,15 +103,20 @@ protected:
       return;
     }
     
-    // Avoid moving on if we are being called after the dtor was started
     // Ensure we call any updates from the draw loop on the javascript thread
     getContext()->runOnJavascriptThread(
-      [this]() {
-      if(_state == RNSkClockState::Running) {
-        auto now = std::chrono::high_resolution_clock::now();
-        auto deltaFromStart = std::chrono::duration_cast<std::chrono::milliseconds>(now - _start).count();
-        tick(_runtime, static_cast<double>(deltaFromStart));
-      }
+      // To ensure that this shared_ptr instance is not deallocated before we are done
+      // running the update lambda we pass a shared from this to the lambda scope.
+      [weakSelf = weak_from_this()]() {
+        auto self = weakSelf.lock();
+        if(self) {
+          auto selfClockValue = std::dynamic_pointer_cast<RNSkClockValue>(self);
+          if(selfClockValue->getState() == RNSkClockState::Running) {
+            auto now = std::chrono::high_resolution_clock::now();
+            auto deltaFromStart = std::chrono::duration_cast<std::chrono::milliseconds>(now - selfClockValue->_start).count();
+            selfClockValue->tick(selfClockValue->_runtime, static_cast<double>(deltaFromStart));
+          }
+        }
     });
   }
   
@@ -127,7 +135,7 @@ protected:
   size_t _identifier;
   std::chrono::time_point<std::chrono::steady_clock> _start;
   std::chrono::time_point<std::chrono::steady_clock> _stop;
-  std::atomic<RNSkClockState> _state;
+  std::atomic<RNSkClockState> _state = { RNSkClockState::NotStarted };
 };
 
 }

package/cpp/rnskia/values/RNSkDerivedValue.h

@@ -39,6 +39,11 @@ public:
       jsi::detail::throwJSError(runtime, "Expected array of dependencies as second parameter");
     }
         
+    // Get callback for calculating result
+    _callback = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
+  }
+  
+  void initializeDependencies(jsi::Runtime &runtime, const jsi::Value *arguments, size_t count) {
     // Save dependencies
     std::vector<std::shared_ptr<RNSkReadonlyValue>> dependencies;
         
@@ -59,21 +64,23 @@ public:
       dependencies.push_back(value);
     }
     
-    // Get callback for calculating result
-    _callback = std::make_shared<jsi::Function>(arguments[0].asObject(runtime).asFunction(runtime));
-
     // register change handler on dependencies
     _unsubscribers.reserve(_unsubscribers.size() + size);
     for(const auto &dep: dependencies) {
-      auto dispatcher = std::bind(&RNSkDerivedValue::dependencyUpdated, this, std::placeholders::_1);
-      _unsubscribers.push_back(dep->addListener(dispatcher));
+      _unsubscribers.push_back(dep->addListener([weakSelf = weak_from_this()](jsi::Runtime& runtime) {
+        auto self = weakSelf.lock();
+        if(self) {
+          auto selfAsThis = std::dynamic_pointer_cast<RNSkDerivedValue>(self);
+          selfAsThis->dependencyUpdated(runtime);
+        }
+      }));
     }
         
     // Set initial value
     dependencyUpdated(runtime);
   }
   
-  ~RNSkDerivedValue() {
+  virtual ~RNSkDerivedValue() {
     // Unregister listeners
     for(const auto &unsubscribe: _unsubscribers) {
       unsubscribe();