Fix event handling

Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -207,6 +207,11 @@ void NativeReanimatedModule::onEvent(std::string eventName, std::string eventAsS
     }
 }
 
+bool NativeReanimatedModule::isAnyHandlerWaitingForEvent(std::string eventName) {
+  return eventHandlerRegistry->isAnyHandlerWaitingForEvent(eventName);
+}
+
+
 void NativeReanimatedModule::maybeRequestRender()
 {
   if (!renderRequested)

Common/cpp/Registries/EventHandlerRegistry.cpp

@@ -8,18 +8,21 @@ static jsi::Value eval(jsi::Runtime &rt, const char *code) {
 }
 
 void EventHandlerRegistry::registerEventHandler(std::shared_ptr<EventHandler> eventHandler) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
   eventMappings[eventHandler->eventName][eventHandler->id] = eventHandler;
   eventHandlers[eventHandler->id] = eventHandler;
 }
 
 void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
   auto handlerIt = eventHandlers.find(id);
   if (handlerIt != eventHandlers.end()) {
     eventMappings[handlerIt->second->eventName].erase(id);
   }
 }
 
 void EventHandlerRegistry::processEvent(jsi::Runtime &rt, std::string eventName, std::string eventPayload) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
   auto handlersIt = eventMappings.find(eventName);
   if (handlersIt != eventMappings.end()) {
     // TODO: use jsi::Value::createFromJsonUtf8
@@ -31,4 +34,9 @@ void EventHandlerRegistry::processEvent(jsi::Runtime &rt, std::string eventName,
   }
 }
 
+bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(std::string eventName) {
+  auto it = eventMappings.find(eventName);
+  return (it != eventMappings.end()) and (!(it->second).empty());
+}
+
 }

Common/cpp/headers/NativeModules/NativeReanimatedModule.h

@@ -51,6 +51,7 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec
 
     void onRender(double timestampMs);
     void onEvent(std::string eventName, std::string eventAsString);
+    bool isAnyHandlerWaitingForEvent(std::string eventName);
 
     void maybeRequestRender();
 

Common/cpp/headers/Registries/EventHandlerRegistry.h

@@ -6,6 +6,7 @@
 #include <unordered_map>
 #include <string>
 #include <jsi/jsi.h>
+#include <mutex>
 
 using namespace facebook;
 
@@ -16,12 +17,14 @@ class EventHandler;
 class EventHandlerRegistry {
   std::map<std::string, std::unordered_map<unsigned long, std::shared_ptr<EventHandler>>> eventMappings;
   std::map<unsigned long, std::shared_ptr<EventHandler>> eventHandlers;
+  std::mutex instanceMutex;
 
 public:
   void registerEventHandler(std::shared_ptr<EventHandler> eventHandler);
   void unregisterEventHandler(unsigned long id);
 
   void processEvent(jsi::Runtime &rt, std::string eventName, std::string eventPayload);
+  bool isAnyHandlerWaitingForEvent(std::string eventName);
 };
 
 }

android/src/main/cpp/NativeProxy.cpp

@@ -10,7 +10,6 @@
 
 #include "NativeProxy.h"
 #include "AndroidErrorHandler.h"
-#include "NativeReanimatedModule.h"
 #include "AndroidScheduler.h"
 #include <android/log.h>
 #include "PlatformDepMethodsHolder.h"
@@ -91,6 +90,8 @@ void NativeProxy::installJSIBindings()
                                                          propObtainer,
                                                          platformDepMethodsHolder);
 
+  _nativeReanimatedModule = module;
+
   this->registerEventHandler([module](std::string eventName, std::string eventAsString) {
     module->onEvent(eventName, eventAsString);
   });
@@ -101,11 +102,16 @@ void NativeProxy::installJSIBindings()
       jsi::Object::createFromHostObject(*runtime_, module));
 }
 
+bool NativeProxy::isAnyHandlerWaitingForEvent(std::string s) {
+  return _nativeReanimatedModule->isAnyHandlerWaitingForEvent(s);
+}
+
 void NativeProxy::registerNatives()
 {
   registerHybrid({
       makeNativeMethod("initHybrid", NativeProxy::initHybrid),
       makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
+      makeNativeMethod("isAnyHandlerWaitingForEvent", NativeProxy::isAnyHandlerWaitingForEvent)
   });
 }
 

android/src/main/cpp/headers/NativeProxy.h

@@ -5,10 +5,12 @@
 #include <react/jni/CxxModuleWrapper.h>
 #include <react/jni/JMessageQueueThread.h>
 #include <react/jni/WritableNativeMap.h>
+#include "NativeReanimatedModule.h"
 #include <ReactCommon/CallInvokerHolder.h>
 #include <memory>
 #include <unordered_map>
 
+
 #include "Scheduler.h"
 #include "AndroidScheduler.h"
 
@@ -89,9 +91,11 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
   jni::global_ref<NativeProxy::javaobject> javaPart_;
   jsi::Runtime *runtime_;
   std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
+  std::shared_ptr<NativeReanimatedModule> _nativeReanimatedModule;
   std::shared_ptr<Scheduler> scheduler_;
 
   void installJSIBindings();
+  bool isAnyHandlerWaitingForEvent(std::string);
   void requestRender(std::function<void(double)> onRender);
   void registerEventHandler(std::function<void(std::string,std::string)> handler);
   void updateProps(jsi::Runtime &rt, int viewTag, const jsi::Object &props);

android/src/main/java/com/swmansion/reanimated/CopiedEvent.java

@@ -0,0 +1,42 @@
+package com.swmansion.reanimated;
+
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import androidx.annotation.Nullable;
+
+public class CopiedEvent {
+  private int targetTag;
+  private String eventName;
+  private WritableMap payload;
+
+  CopiedEvent(Event event) {
+    event.dispatch(new RCTEventEmitter() {
+      @Override
+      public void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event) {
+        CopiedEvent.this.targetTag = targetTag;
+        CopiedEvent.this.eventName = eventName;
+        CopiedEvent.this.payload = event.copy();
+      }
+
+      @Override
+      public void receiveTouches(String eventName, WritableArray touches, WritableArray changedIndices) {
+        //noop
+      }
+    });
+  }
+
+  public int getTargetTag() {
+    return targetTag;
+  }
+
+  public String getEventName() {
+    return eventName;
+  }
+
+  public WritableMap getPayload() {
+    return payload;
+  }
+}

android/src/main/java/com/swmansion/reanimated/NativeProxy.java

@@ -83,6 +83,8 @@ public NativeProxy(ReactApplicationContext context) {
   private native HybridData initHybrid(long jsContext, CallInvokerHolderImpl jsCallInvokerHolder, Scheduler scheduler);
   private native void installJSIBindings();
 
+  public native boolean isAnyHandlerWaitingForEvent(String eventName);
+
   @DoNotStrip
   private void requestRender(AnimationFrameCallback callback) {
     mNodesManager.postOnAnimation(callback);

android/src/main/java/com/swmansion/reanimated/NodesManager.java

@@ -60,6 +60,8 @@
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import javax.annotation.Nullable;
+
 public class NodesManager implements EventDispatcherListener {
 
   private static final Double ZERO = Double.valueOf(0);
@@ -104,7 +106,7 @@ public interface OnAnimationFrame {
 
   private RCTEventEmitter mCustomEventHandler;
   private List<OnAnimationFrame> mFrameCallbacks = new ArrayList<>();
-  private ConcurrentLinkedQueue<Event> mEventQueue = new ConcurrentLinkedQueue<>();
+  private ConcurrentLinkedQueue<CopiedEvent> mEventQueue = new ConcurrentLinkedQueue<>();
   private boolean mWantRunUpdates;
 
   public double currentFrameTimeMs;
@@ -228,7 +230,8 @@ private void onAnimationFrame(long frameTimeNanos) {
     currentFrameTimeMs = frameTimeNanos / 1000000.;
 
     while (!mEventQueue.isEmpty()) {
-      handleEvent(mEventQueue.poll());
+      CopiedEvent copiedEvent = mEventQueue.poll();
+      handleEvent(copiedEvent.getTargetTag(), copiedEvent.getEventName(), copiedEvent.getPayload());
     }
 
     if (!mFrameCallbacks.isEmpty()) {
@@ -445,7 +448,15 @@ public void onEventDispatch(Event event) {
       handleEvent(event);
       performOperations();
     } else {
-      mEventQueue.offer(event);
+      boolean shouldSaveEvent = false;
+      String eventName = mCustomEventNamesResolver.resolveCustomEventName(event.getEventName());
+      int viewTag = event.getViewTag();
+      String key = viewTag + eventName;
+
+      shouldSaveEvent |= (mCustomEventHandler != null && mNativeProxy.isAnyHandlerWaitingForEvent(key));
+      if (shouldSaveEvent) {
+        mEventQueue.offer(new CopiedEvent(event));
+      }
       startUpdatingOnAnimationFrame();
     }
   }
@@ -468,6 +479,21 @@ private void handleEvent(Event event) {
     }
   }
 
+  private void handleEvent(int targetTag, String eventName, @Nullable WritableMap event) {
+    if (mCustomEventHandler != null) {
+      mCustomEventHandler.receiveEvent(targetTag, eventName, event);
+    }
+
+    String key = targetTag + eventName;
+
+    if (!mEventMapping.isEmpty()) {
+      EventNode node = mEventMapping.get(key);
+      if (node != null) {
+        node.receiveEvent(targetTag, eventName, event);
+      }
+    }
+  }
+
   public UIManagerModule.CustomEventNamesResolver getEventNameResolver() {
     return mCustomEventNamesResolver;
   }