scandit-react-native-datacapture-id 8.2.0 → 8.3.0-beta.1

package/ios/Sources/NewArch/ScanditDataCaptureId.mm

@@ -0,0 +1,95 @@
+/*
+ * This file is part of the Scandit Data Capture SDK
+ *
+ * Copyright (C) 2021- Scandit AG. All rights reserved.
+ */
+
+#import <React/RCTEventEmitter.h>
+#import <React/RCTBridgeModule.h>
+#import <ScanditReactNativeDatacaptureIdSpec/ScanditReactNativeDatacaptureIdSpec.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import "ScanditDataCaptureId.h"
+#import "ScanditDataCaptureId-Swift.h"
+
+// Forward declare and import the shared method queue from Core module
+// The actual implementation is in ScanditDataCaptureCore Swift module
+@interface SDCSharedMethodQueue : NSObject
++ (dispatch_queue_t)queue;
+@end
+
+/// New Architecture (TurboModule) adapter for the Id native module.
+/// Inherits from the generated spec base class and uses direct method declarations.
+@implementation NativeScanditDataCaptureId {
+    ScanditDataCaptureIdImpl *_impl;
+}
+
+RCT_EXPORT_MODULE(ScanditDataCaptureId)
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _impl = [[ScanditDataCaptureIdImpl alloc] init];
+    }
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (void)initialize {
+    __weak NativeScanditDataCaptureId *weakSelf = self;
+    SDCEventEmitBlock emitterBlock = ^(NSDictionary *_Nonnull payload) {
+        __strong NativeScanditDataCaptureId *strongSelf = weakSelf;
+        if (strongSelf) {
+            [strongSelf emitOnScanditEvent:payload];
+        }
+    };
+    [_impl setupWith:nil turboEmitter:emitterBlock];
+}
+
+- (dispatch_queue_t)methodQueue {
+    return [SDCSharedMethodQueue queue];
+}
+
+- (NSDictionary *)constantsToExport {
+    return [self getConstantsOnMainQueue];
+}
+
+- (NSDictionary *)getConstants {
+    return [self getConstantsOnMainQueue];
+}
+
+- (NSDictionary *)getConstantsOnMainQueue {
+    __block NSDictionary *constants;
+    if ([NSThread isMainThread]) {
+        constants = [_impl getConstants];
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            constants = [_impl getConstants];
+        });
+    }
+    return constants;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return [_impl supportedEvents];
+}
+
+- (void)invalidate {
+    [_impl invalidate];
+}
+
+// MARK: - Native Module Methods
+
+- (void)executeId:(NSDictionary *)data
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+    [_impl executeIdWithData:data resolve:resolve reject:reject];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativeScanditDataCaptureIdSpecJSI>(params);
+}
+
+@end

package/ios/Sources/OldArch/ScanditDataCaptureId.mm

@@ -0,0 +1,83 @@
+/*
+ * This file is part of the Scandit Data Capture SDK
+ *
+ * Copyright (C) 2021- Scandit AG. All rights reserved.
+ */
+
+#import <React/RCTEventEmitter.h>
+#import <React/RCTBridgeModule.h>
+#import "ScanditDataCaptureId.h"
+#import "ScanditDataCaptureId-Swift.h"
+
+// Forward declare and import the shared method queue from Core module
+// The actual implementation is in ScanditDataCaptureCore Swift module
+@interface SDCSharedMethodQueue : NSObject
++ (dispatch_queue_t)queue;
+@end
+
+/// Old Architecture (Paper/Bridge) adapter for the Id native module.
+/// Inherits from RCTEventEmitter and exports methods via RCT_EXPORT_METHOD macros.
+@implementation NativeScanditDataCaptureId {
+    ScanditDataCaptureIdImpl *_impl;
+}
+
+RCT_EXPORT_MODULE(ScanditDataCaptureId)
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _impl = [[ScanditDataCaptureIdImpl alloc] init];
+    }
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (void)initialize {
+    [_impl setupWith:self];
+}
+
+- (dispatch_queue_t)methodQueue {
+    return [SDCSharedMethodQueue queue];
+}
+
+- (NSDictionary *)constantsToExport {
+    return [self getConstantsOnMainQueue];
+}
+
+- (NSDictionary *)getConstants {
+    return [self getConstantsOnMainQueue];
+}
+
+- (NSDictionary *)getConstantsOnMainQueue {
+    __block NSDictionary *constants;
+    if ([NSThread isMainThread]) {
+        constants = [_impl getConstants];
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            constants = [_impl getConstants];
+        });
+    }
+    return constants;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return [_impl supportedEvents];
+}
+
+- (void)invalidate {
+    [super invalidate];
+    [_impl invalidate];
+}
+
+// MARK: - Native Module Methods
+
+RCT_EXPORT_METHOD(executeId
+                  : (NSDictionary *)data resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject) {
+    [_impl executeIdWithData:data resolve:resolve reject:reject];
+}
+
+@end

package/ios/Sources/ScanditDataCaptureId.h

@@ -3,3 +3,28 @@
  *
  * Copyright (C) 2021- Scandit AG. All rights reserved.
  */
+
+#import <Foundation/Foundation.h>
+#import <React/RCTEventEmitter.h>
+
+// Block type for TurboModule event emission (Swift interop)
+// Defined unconditionally for Swift header generation, used only in new arch
+typedef void (^SDCEventEmitBlock)(NSDictionary *_Nonnull payload);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <ScanditReactNativeDatacaptureIdSpec/ScanditReactNativeDatacaptureIdSpec.h>
+#import <React/RCTInitializing.h>
+#import <React/RCTInvalidating.h>
+#endif
+
+/// Native module for Scandit Data Capture Id.
+/// This Obj-C++ class conforms to the TurboModule spec and delegates to ScanditDataCaptureIdImpl
+/// (Swift). Following the Adapter Pattern from React Native's TurboModule Swift guide.
+#ifdef RCT_NEW_ARCH_ENABLED
+@interface NativeScanditDataCaptureId
+    : NativeScanditDataCaptureIdSpecBase <NativeScanditDataCaptureIdSpec, RCTInitializing,
+                                          RCTInvalidating>
+#else
+@interface NativeScanditDataCaptureId : RCTEventEmitter <RCTBridgeModule>
+#endif
+@end

package/ios/Sources/ScanditDataCaptureId.swift

@@ -10,50 +10,75 @@ import ScanditDataCaptureCore
 import ScanditFrameworksCore
 import ScanditFrameworksId
 
-@objc(ScanditDataCaptureId)
-class ScanditDataCaptureId: RCTEventEmitter {
+/// Swift implementation for the Id native module.
+/// This class contains all business logic and is used by the Obj-C++ adapter (NativeScanditDataCaptureId).
+/// Following the Adapter Pattern from React Native's TurboModule Swift guide.
+@objcMembers
+public class ScanditDataCaptureIdImpl: NSObject {
     var idModule: IdCaptureModule!
 
-    override init() {
-        super.init()
-        let emitter = ReactNativeEmitter(emitter: self)
-        idModule = IdCaptureModule(emitter: emitter)
-        idModule.didStart()
-    }
+    /// Reference to the RCTEventEmitter adapter.
+    weak var emitter: RCTEventEmitter?
 
-    override func supportedEvents() -> [String]! {
-        FrameworksIdCaptureEvent.allCases.map { $0.rawValue }
+    public override init() {
+        super.init()
     }
 
-    override func constantsToExport() -> [AnyHashable: Any]! {
-        [
-            "Defaults": idModule.getDefaults()
-        ]
+    /// Called by the Obj-C++ adapter to set up the emitter reference and initialize modules (old architecture).
+    public func setup(with emitter: RCTEventEmitter) {
+        self.emitter = emitter
+        guard let reactEmitter = ScanditDataCaptureCore.ReactNativeEmitterFactory.create(emitter: emitter) else {
+            fatalError("Failed to create ReactNativeEmitter")
+        }
+        idModule = IdCaptureModule(emitter: reactEmitter)
+        idModule.didStart()
     }
 
-    @objc override class func requiresMainQueueSetup() -> Bool {
-        true
+    /// Called by the Obj-C++ adapter to set up the emitter reference and initialize modules (new architecture).
+    /// - Parameters:
+    ///   - emitter: The RCTEventEmitter (nil in new arch since we don't inherit from RCTEventEmitter).
+    ///   - turboEmitter: TurboModule emitter block for new architecture.
+    @objc(setupWith:turboEmitter:)
+    public func setup(with emitter: RCTEventEmitter?, turboEmitter: SDCEventEmitBlock?) {
+        self.emitter = emitter
+        guard
+            let reactEmitter = ScanditDataCaptureCore.ReactNativeEmitterFactory.create(
+                emitter: emitter,
+                turboEmitter: turboEmitter
+            )
+        else {
+            fatalError("Failed to create ReactNativeEmitter")
+        }
+        idModule = IdCaptureModule(emitter: reactEmitter)
+        idModule.didStart()
     }
 
-    @objc override var methodQueue: DispatchQueue! {
-        sdcSharedMethodQueue
+    public func supportedEvents() -> [String] {
+        FrameworksIdCaptureEvent.allCases.map { $0.rawValue }
     }
 
-    @objc override func invalidate() {
-        super.invalidate()
-        idModule.didStop()
+    public func getConstants() -> [AnyHashable: Any] {
+        guard let module = idModule else {
+            return [:]
+        }
+        return [
+            "Defaults": module.getDefaults()
+        ]
     }
 
-    deinit {
-        invalidate()
+    public func invalidate() {
+        idModule?.didStop()
     }
 
-    @objc(executeId:resolve:reject:)
-    func executeId(
+    public func executeId(
         data: [String: Any],
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
+        guard let module = idModule else {
+            reject("MODULE_NOT_INITIALIZED", "IdModule is not initialized. setup() may not have been called.", nil)
+            return
+        }
 
         let coreModuleName = String(describing: CoreModule.self)
         guard let coreModule = DefaultServiceLocator.shared.resolve(clazzName: coreModuleName) as? CoreModule else {
@@ -65,7 +90,7 @@ class ScanditDataCaptureId: RCTEventEmitter {
         let handled = coreModule.execute(
             ReactNativeMethodCall(data),
             result: result,
-            module: idModule
+            module: module
         )
 
         if !handled {

package/ios/generated/ScanditReactNativeDatacaptureIdSpec/ScanditReactNativeDatacaptureIdSpec-generated.mm

@@ -0,0 +1,53 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#import "ScanditReactNativeDatacaptureIdSpec.h"
+
+
+@implementation NativeScanditDataCaptureIdSpecBase
+- (void)emitOnScanditEvent:(NSDictionary *)value
+{
+  _eventEmitterCallback("onScanditEvent", value);
+}
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+@end
+
+
+namespace facebook::react {
+  
+    static facebook::jsi::Value __hostFunction_NativeScanditDataCaptureIdSpecJSI_executeId(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "executeId", @selector(executeId:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeScanditDataCaptureIdSpecJSI_getConstants(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, ObjectKind, "getConstants", @selector(getConstants), args, count);
+    }
+
+  NativeScanditDataCaptureIdSpecJSI::NativeScanditDataCaptureIdSpecJSI(const ObjCTurboModule::InitParams &params)
+    : ObjCTurboModule(params) {
+      
+        methodMap_["executeId"] = MethodMetadata {1, __hostFunction_NativeScanditDataCaptureIdSpecJSI_executeId};
+        
+        
+        methodMap_["getConstants"] = MethodMetadata {0, __hostFunction_NativeScanditDataCaptureIdSpecJSI_getConstants};
+        
+        eventEmitterMap_["onScanditEvent"] = std::make_shared<AsyncEventEmitter<id>>();
+        setEventEmitterCallback([&](const std::string &name, id value) {
+          static_cast<AsyncEventEmitter<id> &>(*eventEmitterMap_[name]).emit(value);
+        });
+  }
+} // namespace facebook::react

package/ios/generated/ScanditReactNativeDatacaptureIdSpec/ScanditReactNativeDatacaptureIdSpec.h

@@ -0,0 +1,103 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
+
+// Avoid multiple includes of ScanditReactNativeDatacaptureIdSpec symbols
+#ifndef ScanditReactNativeDatacaptureIdSpec_H
+#define ScanditReactNativeDatacaptureIdSpec_H
+
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTCxxConvert.h>
+#import <React/RCTManagedPointer.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <optional>
+#import <vector>
+
+
+NS_ASSUME_NONNULL_BEGIN
+namespace JS {
+  namespace NativeScanditDataCaptureId {
+    struct Constants {
+
+      struct Builder {
+        // Backwards compat for RCTTypedModuleConstants
+        using ResultT = Constants;
+
+        struct Input {
+          RCTRequired<id<NSObject>> Defaults;
+        };
+
+        /** Initialize with a set of values */
+        Builder(const Input i);
+        /** Initialize with an existing Constants */
+        Builder(Constants i);
+        /** Builds the object. Generally used only by the infrastructure. */
+        NSDictionary *buildUnsafeRawValue() const { return _factory(); };
+      private:
+        NSDictionary *(^_factory)(void);
+      };
+
+      static Constants fromUnsafeRawValue(NSDictionary *const v) { return {v}; }
+      NSDictionary *unsafeRawValue() const { return _v; }
+    private:
+      Constants(NSDictionary *const v) : _v(v) {}
+      NSDictionary *_v;
+    };
+  }
+}
+@protocol NativeScanditDataCaptureIdSpec <RCTBridgeModule, RCTTurboModule>
+
+- (void)executeId:(NSDictionary *)data
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject;
+- (facebook::react::ModuleConstants<JS::NativeScanditDataCaptureId::Constants::Builder>)constantsToExport;
+- (facebook::react::ModuleConstants<JS::NativeScanditDataCaptureId::Constants::Builder>)getConstants;
+
+@end
+
+@interface NativeScanditDataCaptureIdSpecBase : NSObject {
+@protected
+facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+
+- (void)emitOnScanditEvent:(NSDictionary *)value;
+@end
+
+namespace facebook::react {
+  /**
+   * ObjC++ class for module 'NativeScanditDataCaptureId'
+   */
+  class JSI_EXPORT NativeScanditDataCaptureIdSpecJSI : public ObjCTurboModule {
+  public:
+    NativeScanditDataCaptureIdSpecJSI(const ObjCTurboModule::InitParams &params);
+  };
+} // namespace facebook::react
+inline JS::NativeScanditDataCaptureId::Constants::Builder::Builder(const Input i) : _factory(^{
+  NSMutableDictionary *d = [NSMutableDictionary new];
+  auto Defaults = i.Defaults.get();
+  d[@"Defaults"] = Defaults;
+  return d;
+}) {}
+inline JS::NativeScanditDataCaptureId::Constants::Builder::Builder(Constants i) : _factory(^{
+  return i.unsafeRawValue();
+}) {}
+NS_ASSUME_NONNULL_END
+#endif // ScanditReactNativeDatacaptureIdSpec_H

package/ios/generated/ScanditReactNativeDatacaptureIdSpecJSI-generated.cpp

@@ -0,0 +1,33 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleCpp.js
+ */
+
+#include "ScanditReactNativeDatacaptureIdSpecJSI.h"
+
+namespace facebook::react {
+
+static jsi::Value __hostFunction_NativeScanditDataCaptureIdCxxSpecJSI_getConstants(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeScanditDataCaptureIdCxxSpecJSI *>(&turboModule)->getConstants(
+    rt
+  );
+}
+static jsi::Value __hostFunction_NativeScanditDataCaptureIdCxxSpecJSI_executeId(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeScanditDataCaptureIdCxxSpecJSI *>(&turboModule)->executeId(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt)
+  );
+}
+
+NativeScanditDataCaptureIdCxxSpecJSI::NativeScanditDataCaptureIdCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
+  : TurboModule("ScanditDataCaptureId", jsInvoker) {
+  methodMap_["getConstants"] = MethodMetadata {0, __hostFunction_NativeScanditDataCaptureIdCxxSpecJSI_getConstants};
+  methodMap_["executeId"] = MethodMetadata {1, __hostFunction_NativeScanditDataCaptureIdCxxSpecJSI_executeId};
+}
+
+
+} // namespace facebook::react

package/ios/generated/ScanditReactNativeDatacaptureIdSpecJSI.h

@@ -0,0 +1,151 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+  
+#pragma mark - NativeScanditDataCaptureIdScanditEventPayload
+
+template <typename P0, typename P1, typename P2, typename P3>
+struct NativeScanditDataCaptureIdScanditEventPayload {
+  P0 name;
+  P1 data;
+  P2 viewId;
+  P3 modeId;
+  bool operator==(const NativeScanditDataCaptureIdScanditEventPayload &other) const {
+    return name == other.name && data == other.data && viewId == other.viewId && modeId == other.modeId;
+  }
+};
+
+template <typename T>
+struct NativeScanditDataCaptureIdScanditEventPayloadBridging {
+  static T types;
+
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result{
+      bridging::fromJs<decltype(types.name)>(rt, value.getProperty(rt, "name"), jsInvoker),
+      bridging::fromJs<decltype(types.data)>(rt, value.getProperty(rt, "data"), jsInvoker),
+      bridging::fromJs<decltype(types.viewId)>(rt, value.getProperty(rt, "viewId"), jsInvoker),
+      bridging::fromJs<decltype(types.modeId)>(rt, value.getProperty(rt, "modeId"), jsInvoker)};
+    return result;
+  }
+
+#ifdef DEBUG
+  static jsi::String nameToJs(jsi::Runtime &rt, decltype(types.name) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String dataToJs(jsi::Runtime &rt, decltype(types.data) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static double viewIdToJs(jsi::Runtime &rt, decltype(types.viewId) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static double modeIdToJs(jsi::Runtime &rt, decltype(types.modeId) value) {
+    return bridging::toJs(rt, value);
+  }
+#endif
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto result = facebook::jsi::Object(rt);
+    result.setProperty(rt, "name", bridging::toJs(rt, value.name, jsInvoker));
+    result.setProperty(rt, "data", bridging::toJs(rt, value.data, jsInvoker));
+    if (value.viewId) {
+      result.setProperty(rt, "viewId", bridging::toJs(rt, value.viewId.value(), jsInvoker));
+    }
+    if (value.modeId) {
+      result.setProperty(rt, "modeId", bridging::toJs(rt, value.modeId.value(), jsInvoker));
+    }
+    return result;
+  }
+};
+
+class JSI_EXPORT NativeScanditDataCaptureIdCxxSpecJSI : public TurboModule {
+protected:
+  NativeScanditDataCaptureIdCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+
+public:
+  virtual jsi::Object getConstants(jsi::Runtime &rt) = 0;
+  virtual jsi::Value executeId(jsi::Runtime &rt, jsi::Object data) = 0;
+
+};
+
+template <typename T>
+class JSI_EXPORT NativeScanditDataCaptureIdCxxSpec : public TurboModule {
+public:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
+    return delegate_.create(rt, propName);
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
+    return delegate_.getPropertyNames(runtime);
+  }
+
+  static constexpr std::string_view kModuleName = "ScanditDataCaptureId";
+
+protected:
+  NativeScanditDataCaptureIdCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(std::string{NativeScanditDataCaptureIdCxxSpec::kModuleName}, jsInvoker),
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+
+  template <typename OnScanditEventType> void emitOnScanditEvent(OnScanditEventType value) {
+    static_assert(bridging::supportsFromJs<OnScanditEventType, jsi::Object>, "value cannnot be converted to jsi::Object");
+    static_cast<AsyncEventEmitter<jsi::Value>&>(*delegate_.eventEmitterMap_["onScanditEvent"]).emit([jsInvoker = jsInvoker_, eventValue = value](jsi::Runtime& rt) -> jsi::Value {
+      return bridging::toJs(rt, eventValue, jsInvoker);
+    });
+  }
+
+private:
+  class Delegate : public NativeScanditDataCaptureIdCxxSpecJSI {
+  public:
+    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
+      NativeScanditDataCaptureIdCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+      eventEmitterMap_["onScanditEvent"] = std::make_shared<AsyncEventEmitter<jsi::Value>>();
+    }
+
+    jsi::Object getConstants(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::getConstants) == 1,
+          "Expected getConstants(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Object>(
+          rt, &T::getConstants, jsInvoker_, instance_);
+    }
+    jsi::Value executeId(jsi::Runtime &rt, jsi::Object data) override {
+      static_assert(
+          bridging::getParameterCount(&T::executeId) == 2,
+          "Expected executeId(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::executeId, jsInvoker_, instance_, std::move(data));
+    }
+
+  private:
+    friend class NativeScanditDataCaptureIdCxxSpec;
+    T *instance_;
+  };
+
+  Delegate delegate_;
+};
+
+} // namespace facebook::react