@qusaieilouti99/call-manager 0.1.31 → 0.1.32

package/android/src/main/java/com/margelo/nitro/qusaieilouti99/callmanager/CallManager.kt

@@ -5,6 +5,9 @@ import com.facebook.proguard.annotations.DoNotStrip
 @DoNotStrip
 class CallManager : HybridCallManagerSpec() {
 
+    // Store the current listener so we can remove it
+    private var currentListener: ((CallEventType, String) -> Unit)? = null
+
     override fun endCall(callId: String) {
         CallEngine.endCall(CallEngine.appContext ?: return, callId)
     }
@@ -29,18 +32,17 @@ class CallManager : HybridCallManagerSpec() {
     }
 
     override fun addListener(
-        event: CallEventType,
-        listener: (payload: String) -> Unit
+        listener: (event: CallEventType, payload: String) -> Unit
     ): () -> Unit {
-        // Register the event handler for this event type
-        val handler: (CallEventType, String) -> Unit = { type, payload ->
-            if (type == event) listener(payload)
-        }
-        CallEngine.setEventHandler(handler)
+        // Register the single listener for all events
+        currentListener = listener
+        CallEngine.setEventHandler(listener)
         // Return a remove function
         return {
-            // Remove the handler (set to null or implement a more advanced listener registry)
-            CallEngine.setEventHandler(null)
+            if (currentListener === listener) {
+                CallEngine.setEventHandler(null)
+                currentListener = null
+            }
         }
     }
 }

package/lib/module/index.js

@@ -12,6 +12,6 @@ export const setAudioRoute = CallManagerHybridObject.setAudioRoute;
 export const keepScreenAwake = CallManagerHybridObject.keepScreenAwake;
 
 // Event emitter: addListener returns a remove function
-export const addCallManagerListener = (event, listener) => CallManagerHybridObject.addListener(event, listener);
+export const addCallManagerListener = listener => CallManagerHybridObject.addListener(listener);
 export { CallEventType };
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","CallEventType","CallManagerHybridObject","createHybridObject","endCall","silenceRingtone","getAudioDevices","setAudioRoute","keepScreenAwake","addCallManagerListener","event","listener","addListener"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAEzD,SAASC,aAAa,QAAQ,oBAAiB;AAE/C,MAAMC,uBAAuB,GAC3BF,YAAY,CAACG,kBAAkB,CAAc,aAAa,CAAC;;AAE7D;AACA,OAAO,MAAMC,OAAO,GAAGF,uBAAuB,CAACE,OAAO;AACtD,OAAO,MAAMC,eAAe,GAAGH,uBAAuB,CAACG,eAAe;AAEtE,OAAO,MAAMC,eAAe,GAAGJ,uBAAuB,CAACI,eAAe;AACtE,OAAO,MAAMC,aAAa,GAAGL,uBAAuB,CAACK,aAAa;AAClE,OAAO,MAAMC,eAAe,GAAGN,uBAAuB,CAACM,eAAe;;AAEtE;AACA,OAAO,MAAMC,sBAAsB,GAAGA,CACpCC,KAAoB,EACpBC,QAAmC,KACpBT,uBAAuB,CAACU,WAAW,CAACF,KAAK,EAAEC,QAAQ,CAAC;AAErE,SAASV,aAAa","ignoreList":[]}
+{"version":3,"names":["NitroModules","CallEventType","CallManagerHybridObject","createHybridObject","endCall","silenceRingtone","getAudioDevices","setAudioRoute","keepScreenAwake","addCallManagerListener","listener","addListener"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAEzD,SAASC,aAAa,QAAQ,oBAAiB;AAE/C,MAAMC,uBAAuB,GAC3BF,YAAY,CAACG,kBAAkB,CAAc,aAAa,CAAC;;AAE7D;AACA,OAAO,MAAMC,OAAO,GAAGF,uBAAuB,CAACE,OAAO;AACtD,OAAO,MAAMC,eAAe,GAAGH,uBAAuB,CAACG,eAAe;AAEtE,OAAO,MAAMC,eAAe,GAAGJ,uBAAuB,CAACI,eAAe;AACtE,OAAO,MAAMC,aAAa,GAAGL,uBAAuB,CAACK,aAAa;AAClE,OAAO,MAAMC,eAAe,GAAGN,uBAAuB,CAACM,eAAe;;AAEtE;AACA,OAAO,MAAMC,sBAAsB,GACjCC,QAAyD,IAC1CR,uBAAuB,CAACS,WAAW,CAACD,QAAQ,CAAC;AAE9D,SAAST,aAAa","ignoreList":[]}

package/lib/typescript/src/CallManager.nitro.d.ts

@@ -9,6 +9,6 @@ export interface CallManager extends HybridObject<{
     getAudioDevices(): string[];
     setAudioRoute(route: string): void;
     keepScreenAwake(keepAwake: boolean): void;
-    addListener(event: CallEventType, listener: (payload: string) => void): () => void;
+    addListener(listener: (event: CallEventType, payload: string) => void): () => void;
 }
 //# sourceMappingURL=CallManager.nitro.d.ts.map

package/lib/typescript/src/CallManager.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CallManager.nitro.d.ts","sourceRoot":"","sources":["../../../src/CallManager.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,WAAW,WAAY,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAEpF,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,eAAe,IAAI,IAAI,CAAC;IAGxB,eAAe,IAAI,MAAM,EAAE,CAAC;IAC5B,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,eAAe,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAG1C,WAAW,CACT,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAClC,MAAM,IAAI,CAAC;CACf"}
+{"version":3,"file":"CallManager.nitro.d.ts","sourceRoot":"","sources":["../../../src/CallManager.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,WAAW,WAAY,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAEpF,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,eAAe,IAAI,IAAI,CAAC;IAGxB,eAAe,IAAI,MAAM,EAAE,CAAC;IAC5B,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,eAAe,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAG1C,WAAW,CACT,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,GACxD,MAAM,IAAI,CAAC;CACf"}

package/lib/typescript/src/index.d.ts

@@ -4,6 +4,6 @@ export declare const silenceRingtone: () => void;
 export declare const getAudioDevices: () => string[];
 export declare const setAudioRoute: (route: string) => void;
 export declare const keepScreenAwake: (keepAwake: boolean) => void;
-export declare const addCallManagerListener: (event: CallEventType, listener: (payload: string) => void) => () => void;
+export declare const addCallManagerListener: (listener: (event: CallEventType, payload: string) => void) => () => void;
 export { CallEventType };
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMhD,eAAO,MAAM,OAAO,0BAAkC,CAAC;AACvD,eAAO,MAAM,eAAe,YAA0C,CAAC;AAEvE,eAAO,MAAM,eAAe,gBAA0C,CAAC;AACvE,eAAO,MAAM,aAAa,yBAAwC,CAAC;AACnE,eAAO,MAAM,eAAe,8BAA0C,CAAC;AAGvE,eAAO,MAAM,sBAAsB,GACjC,OAAO,aAAa,EACpB,UAAU,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,KAClC,MAAM,IAA4D,CAAC;AAEtE,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMhD,eAAO,MAAM,OAAO,0BAAkC,CAAC;AACvD,eAAO,MAAM,eAAe,YAA0C,CAAC;AAEvE,eAAO,MAAM,eAAe,gBAA0C,CAAC;AACvE,eAAO,MAAM,aAAa,yBAAwC,CAAC;AACnE,eAAO,MAAM,eAAe,8BAA0C,CAAC;AAGvE,eAAO,MAAM,sBAAsB,GACjC,UAAU,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,KACxD,MAAM,IAAqD,CAAC;AAE/D,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/nitrogen/generated/android/c++/JFunc_void_CallEventType_std__string.hpp

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_CallEventType_std__string.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include "CallEventType.hpp"
+#include <string>
+#include "JCallEventType.hpp"
+
+namespace margelo::nitro::qusaieilouti99_callmanager {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: CallEventType, payload: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_CallEventType_std__string: public jni::JavaClass<JFunc_void_CallEventType_std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/qusaieilouti99/callmanager/Func_void_CallEventType_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_CallEventType_std__string` instance holds through JNI.
+     */
+    void invoke(CallEventType event, const std::string& payload) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCallEventType> /* event */, jni::alias_ref<jni::JString> /* payload */)>("invoke");
+      method(self(), JCallEventType::fromCpp(event), jni::make_jstring(payload));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_CallEventType_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_CallEventType_std__string_cxx final: public jni::HybridClass<JFunc_void_CallEventType_std__string_cxx, JFunc_void_CallEventType_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_CallEventType_std__string::javaobject> fromCpp(const std::function<void(CallEventType /* event */, const std::string& /* payload */)>& func) {
+      return JFunc_void_CallEventType_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_CallEventType_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JCallEventType> event, jni::alias_ref<jni::JString> payload) {
+      _func(event->toCpp(), payload->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(CallEventType /* event */, const std::string& /* payload */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/qusaieilouti99/callmanager/Func_void_CallEventType_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_CallEventType_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_CallEventType_std__string_cxx(const std::function<void(CallEventType /* event */, const std::string& /* payload */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(CallEventType /* event */, const std::string& /* payload */)> _func;
+  };
+
+} // namespace margelo::nitro::qusaieilouti99_callmanager

package/nitrogen/generated/android/c++/JHybridCallManagerSpec.cpp

@@ -15,8 +15,8 @@ namespace margelo::nitro::qusaieilouti99_callmanager { enum class CallEventType;
 #include <functional>
 #include "JFunc_void.hpp"
 #include "CallEventType.hpp"
+#include "JFunc_void_CallEventType_std__string.hpp"
 #include "JCallEventType.hpp"
-#include "JFunc_void_std__string.hpp"
 
 namespace margelo::nitro::qusaieilouti99_callmanager {
 
@@ -69,9 +69,9 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
     static const auto method = javaClassStatic()->getMethod<void(jboolean /* keepAwake */)>("keepScreenAwake");
     method(_javaPart, keepAwake);
   }
-  std::function<void()> JHybridCallManagerSpec::addListener(CallEventType event, const std::function<void(const std::string& /* payload */)>& listener) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JCallEventType> /* event */, jni::alias_ref<JFunc_void_std__string::javaobject> /* listener */)>("addListener_cxx");
-    auto __result = method(_javaPart, JCallEventType::fromCpp(event), JFunc_void_std__string_cxx::fromCpp(listener));
+  std::function<void()> JHybridCallManagerSpec::addListener(const std::function<void(CallEventType /* event */, const std::string& /* payload */)>& listener) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_CallEventType_std__string::javaobject> /* listener */)>("addListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_CallEventType_std__string_cxx::fromCpp(listener));
     return [&]() -> std::function<void()> {
       if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
         auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);

package/nitrogen/generated/android/c++/JHybridCallManagerSpec.hpp

@@ -56,7 +56,7 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
     std::vector<std::string> getAudioDevices() override;
     void setAudioRoute(const std::string& route) override;
     void keepScreenAwake(bool keepAwake) override;
-    std::function<void()> addListener(CallEventType event, const std::function<void(const std::string& /* payload */)>& listener) override;
+    std::function<void()> addListener(const std::function<void(CallEventType /* event */, const std::string& /* payload */)>& listener) override;
 
   private:
     friend HybridBase;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/qusaieilouti99/callmanager/{Func_void_std__string.kt → Func_void_CallEventType_std__string.kt}

@@ -1,5 +1,5 @@
 ///
-/// Func_void_std__string.kt
+/// Func_void_CallEventType_std__string.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -14,25 +14,25 @@ import com.margelo.nitro.core.*
 import dalvik.annotation.optimization.FastNative
 
 /**
- * Represents the JavaScript callback `(payload: string) => void`.
+ * Represents the JavaScript callback `(event: enum, payload: string) => void`.
  * This can be either implemented in C++ (in which case it might be a callback coming from JS),
  * or in Kotlin/Java (in which case it is a native callback).
  */
 @DoNotStrip
 @Keep
 @Suppress("ClassName", "RedundantUnitReturnType")
-fun interface Func_void_std__string: (String) -> Unit {
+fun interface Func_void_CallEventType_std__string: (CallEventType, String) -> Unit {
   /**
    * Call the given JS callback.
    * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
    */
   @DoNotStrip
   @Keep
-  override fun invoke(payload: String): Unit
+  override fun invoke(event: CallEventType, payload: String): Unit
 }
 
 /**
- * Represents the JavaScript callback `(payload: string) => void`.
+ * Represents the JavaScript callback `(event: enum, payload: string) => void`.
  * This is implemented in C++, via a `std::function<...>`.
  * The callback might be coming from JS.
  */
@@ -43,7 +43,7 @@ fun interface Func_void_std__string: (String) -> Unit {
   "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
   "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
 )
-class Func_void_std__string_cxx: Func_void_std__string {
+class Func_void_CallEventType_std__string_cxx: Func_void_CallEventType_std__string {
   @DoNotStrip
   @Keep
   private val mHybridData: HybridData
@@ -56,25 +56,25 @@ class Func_void_std__string_cxx: Func_void_std__string {
 
   @DoNotStrip
   @Keep
-  override fun invoke(payload: String): Unit
-    = invoke_cxx(payload)
+  override fun invoke(event: CallEventType, payload: String): Unit
+    = invoke_cxx(event,payload)
 
   @FastNative
-  private external fun invoke_cxx(payload: String): Unit
+  private external fun invoke_cxx(event: CallEventType, payload: String): Unit
 }
 
 /**
- * Represents the JavaScript callback `(payload: string) => void`.
- * This is implemented in Java/Kotlin, via a `(String) -> Unit`.
+ * Represents the JavaScript callback `(event: enum, payload: string) => void`.
+ * This is implemented in Java/Kotlin, via a `(CallEventType, String) -> Unit`.
  * The callback is always coming from native.
  */
 @DoNotStrip
 @Keep
 @Suppress("ClassName", "RedundantUnitReturnType", "unused")
-class Func_void_std__string_java(private val function: (String) -> Unit): Func_void_std__string {
+class Func_void_CallEventType_std__string_java(private val function: (CallEventType, String) -> Unit): Func_void_CallEventType_std__string {
   @DoNotStrip
   @Keep
-  override fun invoke(payload: String): Unit {
-    return this.function(payload)
+  override fun invoke(event: CallEventType, payload: String): Unit {
+    return this.function(event, payload)
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/qusaieilouti99/callmanager/HybridCallManagerSpec.kt

@@ -60,12 +60,12 @@ abstract class HybridCallManagerSpec: HybridObject() {
   @Keep
   abstract fun keepScreenAwake(keepAwake: Boolean): Unit
   
-  abstract fun addListener(event: CallEventType, listener: (payload: String) -> Unit): () -> Unit
+  abstract fun addListener(listener: (event: CallEventType, payload: String) -> Unit): () -> Unit
   
   @DoNotStrip
   @Keep
-  private fun addListener_cxx(event: CallEventType, listener: Func_void_std__string): Func_void {
-    val __result = addListener(event, listener)
+  private fun addListener_cxx(listener: Func_void_CallEventType_std__string): Func_void {
+    val __result = addListener(listener)
     return Func_void_java(__result)
   }
 

package/nitrogen/generated/android/qusaieilouti99_callmanagerOnLoad.cpp

@@ -17,7 +17,7 @@
 
 #include "JHybridCallManagerSpec.hpp"
 #include "JFunc_void.hpp"
-#include "JFunc_void_std__string.hpp"
+#include "JFunc_void_CallEventType_std__string.hpp"
 #include <NitroModules/JNISharedPtr.hpp>
 #include <NitroModules/DefaultConstructableObject.hpp>
 
@@ -32,7 +32,7 @@ int initialize(JavaVM* vm) {
     // Register native JNI methods
     margelo::nitro::qusaieilouti99_callmanager::JHybridCallManagerSpec::registerNatives();
     margelo::nitro::qusaieilouti99_callmanager::JFunc_void_cxx::registerNatives();
-    margelo::nitro::qusaieilouti99_callmanager::JFunc_void_std__string_cxx::registerNatives();
+    margelo::nitro::qusaieilouti99_callmanager::JFunc_void_CallEventType_std__string_cxx::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(

package/nitrogen/generated/ios/CallManager-Swift-Cxx-Bridge.cpp

@@ -21,11 +21,11 @@ namespace margelo::nitro::qusaieilouti99_callmanager::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const std::string& /* payload */)>
-  Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = CallManager::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::string& payload) mutable -> void {
-      swiftClosure.call(payload);
+  // pragma MARK: std::function<void(CallEventType /* event */, const std::string& /* payload */)>
+  Func_void_CallEventType_std__string create_Func_void_CallEventType_std__string(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = CallManager::Func_void_CallEventType_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](CallEventType event, const std::string& payload) mutable -> void {
+      swiftClosure.call(static_cast<int>(event), payload);
     };
   }
   

package/nitrogen/generated/ios/CallManager-Swift-Cxx-Bridge.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `CallEventType` to properly resolve imports.
+namespace margelo::nitro::qusaieilouti99_callmanager { enum class CallEventType; }
 // Forward declaration of `HybridCallManagerSpec` to properly resolve imports.
 namespace margelo::nitro::qusaieilouti99_callmanager { class HybridCallManagerSpec; }
 
@@ -16,6 +18,7 @@ namespace margelo::nitro::qusaieilouti99_callmanager { class HybridCallManagerSp
 namespace CallManager { class HybridCallManagerSpec_cxx; }
 
 // Include C++ defined types
+#include "CallEventType.hpp"
 #include "HybridCallManagerSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -63,26 +66,26 @@ namespace margelo::nitro::qusaieilouti99_callmanager::bridge::swift {
     return Func_void_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::function<void(const std::string& /* payload */)>
+  // pragma MARK: std::function<void(CallEventType /* event */, const std::string& /* payload */)>
   /**
-   * Specialized version of `std::function<void(const std::string&)>`.
+   * Specialized version of `std::function<void(CallEventType, const std::string&)>`.
    */
-  using Func_void_std__string = std::function<void(const std::string& /* payload */)>;
+  using Func_void_CallEventType_std__string = std::function<void(CallEventType /* event */, const std::string& /* payload */)>;
   /**
-   * Wrapper class for a `std::function<void(const std::string& / * payload * /)>`, this can be used from Swift.
+   * Wrapper class for a `std::function<void(CallEventType / * event * /, const std::string& / * payload * /)>`, this can be used from Swift.
    */
-  class Func_void_std__string_Wrapper final {
+  class Func_void_CallEventType_std__string_Wrapper final {
   public:
-    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* payload */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* payload */)>>(std::move(func))) {}
-    inline void call(std::string payload) const {
-      _function->operator()(payload);
+    explicit Func_void_CallEventType_std__string_Wrapper(std::function<void(CallEventType /* event */, const std::string& /* payload */)>&& func): _function(std::make_unique<std::function<void(CallEventType /* event */, const std::string& /* payload */)>>(std::move(func))) {}
+    inline void call(int event, std::string payload) const {
+      _function->operator()(static_cast<CallEventType>(event), payload);
     }
   private:
-    std::unique_ptr<std::function<void(const std::string& /* payload */)>> _function;
+    std::unique_ptr<std::function<void(CallEventType /* event */, const std::string& /* payload */)>> _function;
   } SWIFT_NONCOPYABLE;
-  Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper);
-  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) {
-    return Func_void_std__string_Wrapper(std::move(value));
+  Func_void_CallEventType_std__string create_Func_void_CallEventType_std__string(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_CallEventType_std__string_Wrapper wrap_Func_void_CallEventType_std__string(Func_void_CallEventType_std__string value) {
+    return Func_void_CallEventType_std__string_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::shared_ptr<margelo::nitro::qusaieilouti99_callmanager::HybridCallManagerSpec>

package/nitrogen/generated/ios/c++/HybridCallManagerSpecSwift.hpp

@@ -91,8 +91,8 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
         std::rethrow_exception(__result.error());
       }
     }
-    inline std::function<void()> addListener(CallEventType event, const std::function<void(const std::string& /* payload */)>& listener) override {
-      auto __result = _swiftPart.addListener(static_cast<int>(event), listener);
+    inline std::function<void()> addListener(const std::function<void(CallEventType /* event */, const std::string& /* payload */)>& listener) override {
+      auto __result = _swiftPart.addListener(listener);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/{Func_void_std__string.swift → Func_void_CallEventType_std__string.swift}

@@ -1,5 +1,5 @@
 ///
-/// Func_void_std__string.swift
+/// Func_void_CallEventType_std__string.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -8,21 +8,21 @@
 import NitroModules
 
 /**
- * Wraps a Swift `(_ payload: String) -> Void` as a class.
+ * Wraps a Swift `(_ event: CallEventType, _ payload: String) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
  */
-public final class Func_void_std__string {
+public final class Func_void_CallEventType_std__string {
   public typealias bridge = margelo.nitro.qusaieilouti99_callmanager.bridge.swift
 
-  private let closure: (_ payload: String) -> Void
+  private let closure: (_ event: CallEventType, _ payload: String) -> Void
 
-  public init(_ closure: @escaping (_ payload: String) -> Void) {
+  public init(_ closure: @escaping (_ event: CallEventType, _ payload: String) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(payload: std.string) -> Void {
-    self.closure(String(payload))
+  public func call(event: Int32, payload: std.string) -> Void {
+    self.closure(margelo.nitro.qusaieilouti99_callmanager.CallEventType(rawValue: event)!, String(payload))
   }
 
   /**
@@ -35,12 +35,12 @@ public final class Func_void_std__string {
   }
 
   /**
-   * Casts an unsafe pointer to a `Func_void_std__string`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__string>`.
+   * Casts an unsafe pointer to a `Func_void_CallEventType_std__string`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_CallEventType_std__string>`.
    * This removes one strong reference from the object!
    */
   @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__string {
-    return Unmanaged<Func_void_std__string>.fromOpaque(pointer).takeRetainedValue()
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_CallEventType_std__string {
+    return Unmanaged<Func_void_CallEventType_std__string>.fromOpaque(pointer).takeRetainedValue()
   }
 }

package/nitrogen/generated/ios/swift/HybridCallManagerSpec.swift

@@ -19,7 +19,7 @@ public protocol HybridCallManagerSpec_protocol: HybridObject {
   func getAudioDevices() throws -> [String]
   func setAudioRoute(route: String) throws -> Void
   func keepScreenAwake(keepAwake: Bool) throws -> Void
-  func addListener(event: CallEventType, listener: @escaping (_ payload: String) -> Void) throws -> () -> Void
+  func addListener(listener: @escaping (_ event: CallEventType, _ payload: String) -> Void) throws -> () -> Void
 }
 
 /// See ``HybridCallManagerSpec``

package/nitrogen/generated/ios/swift/HybridCallManagerSpec_cxx.swift

@@ -163,12 +163,12 @@ public class HybridCallManagerSpec_cxx {
   }
   
   @inline(__always)
-  public final func addListener(event: Int32, listener: bridge.Func_void_std__string) -> bridge.Result_std__function_void____ {
+  public final func addListener(listener: bridge.Func_void_CallEventType_std__string) -> bridge.Result_std__function_void____ {
     do {
-      let __result = try self.__implementation.addListener(event: margelo.nitro.qusaieilouti99_callmanager.CallEventType(rawValue: event)!, listener: { () -> (String) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_std__string(listener)
-        return { (__payload: String) -> Void in
-          __wrappedFunction.call(std.string(__payload))
+      let __result = try self.__implementation.addListener(listener: { () -> (CallEventType, String) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_CallEventType_std__string(listener)
+        return { (__event: CallEventType, __payload: String) -> Void in
+          __wrappedFunction.call(__event.rawValue, std.string(__payload))
         }
       }())
       let __resultCpp = { () -> bridge.Func_void in

package/nitrogen/generated/shared/c++/HybridCallManagerSpec.hpp

@@ -57,7 +57,7 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
       virtual std::vector<std::string> getAudioDevices() = 0;
       virtual void setAudioRoute(const std::string& route) = 0;
       virtual void keepScreenAwake(bool keepAwake) = 0;
-      virtual std::function<void()> addListener(CallEventType event, const std::function<void(const std::string& /* payload */)>& listener) = 0;
+      virtual std::function<void()> addListener(const std::function<void(CallEventType /* event */, const std::string& /* payload */)>& listener) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qusaieilouti99/call-manager",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "description": "Call manager",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/CallManager.nitro.ts

@@ -13,7 +13,6 @@ export interface CallManager extends HybridObject<{ ios: 'swift'; android: 'kotl
 
   // Event emitter: addListener returns a remove function
   addListener(
-    event: CallEventType,
-    listener: (payload: string) => void
+    listener: (event: CallEventType, payload: string) => void
   ): () => void;
 }

package/src/index.tsx

@@ -15,8 +15,7 @@ export const keepScreenAwake = CallManagerHybridObject.keepScreenAwake;
 
 // Event emitter: addListener returns a remove function
 export const addCallManagerListener = (
-  event: CallEventType,
-  listener: (payload: string) => void
-): () => void => CallManagerHybridObject.addListener(event, listener);
+  listener: (event: CallEventType, payload: string) => void
+): () => void => CallManagerHybridObject.addListener(listener);
 
 export { CallEventType };

package/nitrogen/generated/android/c++/JFunc_void_std__string.hpp

@@ -1,75 +0,0 @@
-///
-/// JFunc_void_std__string.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <functional>
-
-#include <functional>
-#include <string>
-
-namespace margelo::nitro::qusaieilouti99_callmanager {
-
-  using namespace facebook;
-
-  /**
-   * Represents the Java/Kotlin callback `(payload: String) -> Unit`.
-   * This can be passed around between C++ and Java/Kotlin.
-   */
-  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/qusaieilouti99/callmanager/Func_void_std__string;";
-
-  public:
-    /**
-     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
-     */
-    void invoke(const std::string& payload) const {
-      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* payload */)>("invoke");
-      method(self(), jni::make_jstring(payload));
-    }
-  };
-
-  /**
-   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
-   */
-  struct JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
-  public:
-    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* payload */)>& func) {
-      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
-    }
-
-  public:
-    /**
-     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
-     */
-    void invoke_cxx(jni::alias_ref<jni::JString> payload) {
-      _func(payload->toStdString());
-    }
-
-  public:
-    [[nodiscard]]
-    inline const std::function<void(const std::string& /* payload */)>& getFunction() const {
-      return _func;
-    }
-
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/qusaieilouti99/callmanager/Func_void_std__string_cxx;";
-    static void registerNatives() {
-      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
-    }
-
-  private:
-    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* payload */)>& func): _func(func) { }
-
-  private:
-    friend HybridBase;
-    std::function<void(const std::string& /* payload */)> _func;
-  };
-
-} // namespace margelo::nitro::qusaieilouti99_callmanager