anyline-ocr-react-native-module 55.9.0 → 56.0.0

package/AnylineInfinityPlugin.ts

@@ -0,0 +1,129 @@
+import { NativeModules, NativeEventEmitter, EmitterSubscription } from 'react-native';
+import { version as pluginVersion } from './package.json';
+import {
+  WrapperSessionSdkInitializationRequest,
+  WrapperSessionSdkInitializationResponse,
+  WrapperSessionScanStartRequest,
+  WrapperSessionScanResponse,
+  WrapperSessionScanResultsResponse,
+  WrapperSessionScanStopRequest,
+  WrapperSessionUcrReportRequest,
+  WrapperSessionUcrReportResponse,
+  WrapperSessionExportCachedEventsResponse,
+} from './types/wrapper_session_parameters';
+import { UiFeedbackElementConfig } from './types/sdk_config';
+
+export * from './types/wrapper_session_parameters';
+export * from './types/sdk_config';
+
+const MODULE_NAME = 'AnylineInfinityPlugin';
+const EVENT_ON_SCAN_RESULTS = 'INFINITY_ON_SCAN_RESULTS';
+const EVENT_ON_UI_ELEMENT_CLICKED = 'INFINITY_ON_UI_ELEMENT_CLICKED';
+
+const nativeModule = NativeModules[MODULE_NAME];
+const emitter = new NativeEventEmitter(nativeModule);
+
+let _sessionReady = false;
+
+function _setupWrapperSessionOnce(): void {
+    if (_sessionReady) return;
+    _sessionReady = true;
+    nativeModule.setupWrapperSession(pluginVersion);
+}
+
+/// Entrypoint for the Anyline Infinity scanning API.
+///
+/// Exposes a typed, schema-driven interface that mirrors WrapperSessionProvider
+/// directly. JSON serialization/deserialization is handled in this TypeScript
+/// layer; the native bridge only passes raw JSON strings.
+export class AnylineInfinityPlugin {
+  /// Returns the plugin version string.
+  getPluginVersion(): string {
+    _setupWrapperSessionOnce();
+    return pluginVersion;
+  }
+
+  /// Returns the native SDK version string.
+  getSDKVersion(): Promise<string> {
+    _setupWrapperSessionOnce();
+    return nativeModule.getSDKVersion();
+  }
+
+  /// Initializes the Anyline SDK with the supplied request parameters.
+  requestSdkInitialization(
+    request: WrapperSessionSdkInitializationRequest
+  ): Promise<WrapperSessionSdkInitializationResponse> {
+    _setupWrapperSessionOnce();
+    return nativeModule
+      .requestSdkInitialization(JSON.stringify(request))
+      .then((json: string) => JSON.parse(json) as WrapperSessionSdkInitializationResponse);
+  }
+
+  /// Starts a scanning session.
+  ///
+  /// Resolves with the lifecycle response when the session ends
+  /// (success / failure / abort). Intermediate scan results and UI element
+  /// click events arrive via onScanResults and onUIElementClicked.
+  requestScanStart(
+    request: WrapperSessionScanStartRequest
+  ): Promise<WrapperSessionScanResponse> {
+    return nativeModule
+      .requestScanStart(JSON.stringify(request))
+      .then((json: string) => JSON.parse(json) as WrapperSessionScanResponse);
+  }
+
+  /// Switches to a new scan mode using the provided scan-start request.
+  requestScanSwitchWithScanStartRequestParams(
+    request: WrapperSessionScanStartRequest
+  ): void {
+    nativeModule.requestScanSwitchWithScanStartRequestParams(JSON.stringify(request));
+  }
+
+  /// Switches to a new scan mode using a raw ScanViewConfig JSON string.
+  requestScanSwitchWithScanViewConfigContentString(
+    scanViewConfigContentString: string
+  ): void {
+    nativeModule.requestScanSwitchWithScanViewConfigContentString(
+      scanViewConfigContentString
+    );
+  }
+
+  /// Stops the active scanning session.
+  requestScanStop(request?: WrapperSessionScanStopRequest): void {
+    nativeModule.requestScanStop(request ? JSON.stringify(request) : null);
+  }
+
+  /// Submits a User Corrected Result (UCR) report.
+  requestUCRReport(
+    request: WrapperSessionUcrReportRequest
+  ): Promise<WrapperSessionUcrReportResponse> {
+    return nativeModule
+      .requestUCRReport(JSON.stringify(request))
+      .then((json: string) => JSON.parse(json) as WrapperSessionUcrReportResponse);
+  }
+
+  /// Exports all cached scan events as a ZIP archive.
+  requestExportCachedEvents(): Promise<WrapperSessionExportCachedEventsResponse> {
+    return nativeModule
+      .requestExportCachedEvents()
+      .then((json: string) => JSON.parse(json) as WrapperSessionExportCachedEventsResponse);
+  }
+
+  /// Subscribes to scan results emitted during the active scan session (0..N).
+  onScanResults(
+    callback: (scanResults: WrapperSessionScanResultsResponse) => void
+  ): EmitterSubscription {
+    return emitter.addListener(EVENT_ON_SCAN_RESULTS, (json: string) => {
+      callback(JSON.parse(json) as WrapperSessionScanResultsResponse);
+    });
+  }
+
+  /// Subscribes to UI element click events during the active scan session (0..N).
+  onUIElementClicked(
+    callback: (uiElementClicked: UiFeedbackElementConfig) => void
+  ): EmitterSubscription {
+    return emitter.addListener(EVENT_ON_UI_ELEMENT_CLICKED, (json: string) => {
+      callback(JSON.parse(json) as UiFeedbackElementConfig);
+    });
+  }
+}

package/AnylineReact.podspec

@@ -18,7 +18,7 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/Anyline/anyline-ocr-react-native-module.git", :tag => "#{s.version}" }
 
   s.source_files = 'ios/**/*.{h,m,swift}'
-  s.dependency "Anyline", "55.9.0"
+  s.dependency "Anyline", "56.0.0"
   s.dependency "React"
 
 end

package/android/build.gradle

@@ -61,6 +61,6 @@ repositories {
 
 dependencies {
     implementation fileTree(dir: "libs", include: ["*.jar"])
-    implementation 'io.anyline:anylinesdk:55.9.0'
+    implementation 'io.anyline:anylinesdk:56.0.0'
     implementation "com.facebook.react:react-native:+"
 }

package/android/src/main/java/com/anyline/reactnative/AnylineInfinityPlugin.java

@@ -0,0 +1,195 @@
+package com.anyline.reactnative;
+
+import android.content.Context;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.anyline.reactnative.nativeview.NativeViewRegistry;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import org.jetbrains.annotations.NotNull;
+
+import io.anyline.plugin.config.UIFeedbackElementConfig;
+import io.anyline.wrapper.config.WrapperSessionExportCachedEventsResponse;
+import io.anyline.wrapper.config.WrapperSessionScanResponse;
+import io.anyline.wrapper.config.WrapperSessionScanResultConfig;
+import io.anyline.wrapper.config.WrapperSessionScanResultsResponse;
+import io.anyline.wrapper.config.WrapperSessionSdkInitializationResponse;
+import io.anyline.wrapper.config.WrapperSessionUCRReportResponse;
+import io.anyline2.WrapperInfo;
+import io.anyline2.sdk.extension.UIFeedbackElementConfigExtensionKt;
+import io.anyline2.wrapper.WrapperSessionClientInterface;
+import io.anyline2.wrapper.WrapperSessionProvider;
+import io.anyline2.wrapper.extensions.WrapperSessionExportCachedEventsResponseExtensionKt;
+import io.anyline2.wrapper.extensions.WrapperSessionScanResponseExtensionKt;
+import io.anyline2.wrapper.extensions.WrapperSessionScanResultsResponseExtensionKt;
+import io.anyline2.wrapper.extensions.WrapperSessionSdkInitializationResponseExtensionKt;
+import io.anyline2.wrapper.extensions.WrapperSessionUCRReportResponseExtensionKt;
+
+class AnylineInfinityPlugin extends ReactContextBaseJavaModule
+        implements WrapperSessionClientInterface {
+
+    // Retain the WrapperSessionProvider instance to prevent GC-related crashes.
+    protected static final WrapperSessionProvider wrapperSessionProvider = WrapperSessionProvider.INSTANCE;
+
+    static final String REACT_CLASS = "AnylineInfinityPlugin";
+    private static final String EVENT_ON_SCAN_RESULTS = "INFINITY_ON_SCAN_RESULTS";
+    private static final String EVENT_ON_UI_ELEMENT_CLICKED = "INFINITY_ON_UI_ELEMENT_CLICKED";
+
+    private final ReactApplicationContext reactContext;
+
+    private Promise sdkInitializationPromise = null;
+    private Promise scanResponsePromise = null;
+    private Promise ucrReportPromise = null;
+    private Promise exportCachedEventsPromise = null;
+
+    AnylineInfinityPlugin(ReactApplicationContext context) {
+        super(context);
+        this.reactContext = context;
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactMethod
+    public void getSDKVersion(final Promise promise) {
+        promise.resolve(at.nineyards.anyline.BuildConfig.VERSION_NAME);
+    }
+
+    @ReactMethod
+    protected void setupWrapperSession(final String pluginVersion) {
+        WrapperInfo wrapperInfo = new WrapperInfo(
+                WrapperInfo.WrapperType.ReactNative,
+                pluginVersion,
+                WrapperInfo.WrapperCodename.Infinity);
+        WrapperSessionProvider.setupWrapperSession(wrapperInfo, this);
+    }
+
+    @ReactMethod
+    public void requestSdkInitialization(String request, Promise promise) {
+        sdkInitializationPromise = promise;
+        WrapperSessionProvider.requestSdkInitialization(request);
+    }
+
+    @ReactMethod
+    public void requestScanStart(String request, Promise promise) {
+        scanResponsePromise = promise;
+        UiThreadUtil.runOnUiThread(() -> {
+            try {
+                WrapperSessionProvider.requestScanStart(request);
+            } catch (Exception e) {
+                promise.reject(e);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void requestScanSwitchWithScanStartRequestParams(String request) {
+        WrapperSessionProvider.requestScanSwitchWithScanStartRequestParams(request);
+    }
+
+    @ReactMethod
+    public void requestScanSwitchWithScanViewConfigContentString(String request) {
+        WrapperSessionProvider.requestScanSwitchWithScanViewConfigContentString(request);
+    }
+
+    @ReactMethod
+    public void requestScanStop(@Nullable String request) {
+        WrapperSessionProvider.requestScanStop(request);
+    }
+
+    @ReactMethod
+    public void requestUCRReport(String request, Promise promise) {
+        ucrReportPromise = promise;
+        WrapperSessionProvider.requestUCRReport(request);
+    }
+
+    @ReactMethod
+    public void requestExportCachedEvents(Promise promise) {
+        exportCachedEventsPromise = promise;
+        WrapperSessionProvider.requestExportCachedEvents();
+    }
+
+    private void sendEvent(String eventName, String params) {
+        reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(eventName, params);
+    }
+
+    @Override
+    public @NotNull Context getContext() {
+        return reactContext;
+    }
+
+    @Override
+    public @Nullable ViewGroup getContainerView() {
+        return (ViewGroup) NativeViewRegistry.getLastOrNull();
+    }
+
+    @Override
+    public void onSdkInitializationResponse(
+            @NotNull WrapperSessionSdkInitializationResponse initializationResponse) {
+        if (sdkInitializationPromise != null) {
+            sdkInitializationPromise.resolve(
+                    WrapperSessionSdkInitializationResponseExtensionKt
+                            .toJsonObject(initializationResponse).toString());
+            sdkInitializationPromise = null;
+        }
+    }
+
+    @Override
+    public void onScanResults(@NotNull WrapperSessionScanResultsResponse scanResultsResponse) {
+        sendEvent(EVENT_ON_SCAN_RESULTS,
+                WrapperSessionScanResultsResponseExtensionKt
+                        .toJsonObject(scanResultsResponse).toString());
+    }
+
+    @Override
+    public void onScanResponse(@NotNull WrapperSessionScanResponse scanResponse) {
+        if (scanResponsePromise != null) {
+            scanResponsePromise.resolve(
+                    WrapperSessionScanResponseExtensionKt
+                            .toJsonObject(scanResponse).toString());
+            scanResponsePromise = null;
+        }
+    }
+
+    @Override
+    public void onUIElementClicked(
+            @NonNull WrapperSessionScanResultConfig scanResultConfig,
+            @NonNull UIFeedbackElementConfig uiFeedbackElementConfig) {
+        sendEvent(EVENT_ON_UI_ELEMENT_CLICKED,
+                UIFeedbackElementConfigExtensionKt.toJsonObject(uiFeedbackElementConfig).toString());
+    }
+
+    @Override
+    public void onUCRReportResponse(@NotNull WrapperSessionUCRReportResponse ucrReportResponse) {
+        if (ucrReportPromise != null) {
+            ucrReportPromise.resolve(
+                    WrapperSessionUCRReportResponseExtensionKt
+                            .toJsonObject(ucrReportResponse).toString());
+            ucrReportPromise = null;
+        }
+    }
+
+    @Override
+    public void onExportCachedEventsResponse(
+            @NotNull WrapperSessionExportCachedEventsResponse exportCachedEventsResponse) {
+        if (exportCachedEventsPromise != null) {
+            exportCachedEventsPromise.resolve(
+                    WrapperSessionExportCachedEventsResponseExtensionKt
+                            .toJsonObject(exportCachedEventsResponse).toString());
+            exportCachedEventsPromise = null;
+        }
+    }
+}

package/android/src/main/java/com/anyline/reactnative/AnylinePackage.java

@@ -35,6 +35,7 @@ public class AnylinePackage implements ReactPackage {
     public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
         List<NativeModule> modules = new ArrayList<>();
         modules.add(new AnylineSDKPlugin(reactContext));
+        modules.add(new AnylineInfinityPlugin(reactContext));
         return modules;
     }
 }

package/android/src/main/java/com/anyline/reactnative/AnylineSDKPlugin.java

@@ -50,6 +50,10 @@ import io.anyline2.wrapper.extensions.WrapperSessionSdkInitializationResponseExt
 import io.anyline2.wrapper.extensions.WrapperSessionUCRReportRequestExtensionKt;
 import io.anyline2.wrapper.legacy.LegacyPluginHelper;
 
+/**
+ * @deprecated Use {@link AnylineInfinityPlugin} instead.
+ */
+@Deprecated
 class AnylineSDKPlugin extends ReactContextBaseJavaModule
         implements WrapperSessionClientInterface, ResultReporter.OnResultListener {
 
@@ -102,7 +106,7 @@ class AnylineSDKPlugin extends ReactContextBaseJavaModule
 
     @ReactMethod
     protected void setupWrapperSession(final String pluginVersion) {
-        WrapperInfo wrapperInfo = new WrapperInfo(WrapperInfo.WrapperType.ReactNative, pluginVersion);
+        WrapperInfo wrapperInfo = new WrapperInfo(WrapperInfo.WrapperType.ReactNative, pluginVersion, WrapperInfo.WrapperCodename.Legacy);
         WrapperSessionProvider.setupWrapperSession(wrapperInfo,this);
     }
 

package/android/src/main/java/com/anyline/reactnative/ResultReporter.java

@@ -4,6 +4,7 @@ package com.anyline.reactnative;
  * Created by jonesBoi on 02.12.16.
  */
 
+@Deprecated
 public class ResultReporter {
 
     private static OnResultListener listener;

package/index.js

@@ -1,6 +1,9 @@
 import {NativeModules} from 'react-native';
 import {version as pluginVersion} from './package.json';
 
+/**
+ * @deprecated Use AnylineInfinityPlugin instead.
+ */
 const AnylineOCR = NativeModules.AnylineSDKPlugin;
 
 export default AnylineOCR;

package/ios/AnylineInfinityPlugin.h

@@ -0,0 +1,9 @@
+
+#import <Foundation/Foundation.h>
+#import <Anyline/Anyline.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTBridgeModule.h>
+
+@interface AnylineInfinityPlugin : RCTEventEmitter <RCTBridgeModule, ALWrapperSessionClientDelegate>
+
+@end

package/ios/AnylineInfinityPlugin.m

@@ -0,0 +1,197 @@
+
+#import <React/RCTEventEmitter.h>
+#import <React/RCTBridge.h>
+#import "AnylineInfinityPlugin.h"
+#import "NativeView/NativeViewRegistry.h"
+#import "RCTUtils.h"
+
+// Static instance to retain the ALWrapperSessionProvider reference.
+static ALWrapperSessionProvider *_infinityWrapperSessionProvider;
+
+static NSString * const kEventOnScanResults = @"INFINITY_ON_SCAN_RESULTS";
+static NSString * const kEventOnUiElementClicked = @"INFINITY_ON_UI_ELEMENT_CLICKED";
+
+@interface AnylineInfinityPlugin ()
+
+@property (nonatomic, strong) RCTPromiseResolveBlock sdkInitializationResolve;
+@property (nonatomic, strong) RCTPromiseRejectBlock sdkInitializationReject;
+
+@property (nonatomic, strong) RCTPromiseResolveBlock scanResponseResolve;
+@property (nonatomic, strong) RCTPromiseRejectBlock scanResponseReject;
+
+@property (nonatomic, strong) RCTPromiseResolveBlock ucrReportResolve;
+@property (nonatomic, strong) RCTPromiseRejectBlock ucrReportReject;
+
+@property (nonatomic, strong) RCTPromiseResolveBlock exportCachedEventsResolve;
+@property (nonatomic, strong) RCTPromiseRejectBlock exportCachedEventsReject;
+
+@end
+
+@implementation AnylineInfinityPlugin
+
+- (instancetype)init {
+    self = [super initWithDisabledObservation];
+    if (self && !_infinityWrapperSessionProvider) {
+        _infinityWrapperSessionProvider = [[ALWrapperSessionProvider alloc] init];
+    }
+    return self;
+}
+
+RCT_EXPORT_MODULE();
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[kEventOnScanResults, kEventOnUiElementClicked];
+}
+
+RCT_EXPORT_METHOD(getSDKVersion:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    resolve(AnylineSDK.versionNumber);
+}
+
+RCT_EXPORT_METHOD(setupWrapperSession:(NSString *)pluginVersion) {
+    ALWrapperConfig *wrapperConfig = [ALWrapperConfig reactNative:pluginVersion codename:ALWrapperCodenameInfinity];
+    [ALWrapperSessionProvider setupWrapperSessionWithWrapperInfo:wrapperConfig
+                                            wrapperSessionClient:self];
+}
+
+RCT_EXPORT_METHOD(requestSdkInitialization:(NSString *)request
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    self.sdkInitializationResolve = resolve;
+    self.sdkInitializationReject = reject;
+    [ALWrapperSessionProvider
+        requestSdkInitializationWithInitializationRequestParamsString:request];
+}
+
+RCT_EXPORT_METHOD(requestScanStart:(NSString *)request
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    self.scanResponseResolve = resolve;
+    self.scanResponseReject = reject;
+    [ALWrapperSessionProvider requestScanStartWithScanStartRequestParamsString:[self resolvedScanStartRequestJsonString:request]];
+}
+
+RCT_EXPORT_METHOD(requestScanSwitchWithScanStartRequestParams:(NSString *)request) {
+    [ALWrapperSessionProvider requestScanSwitchWithScanStartRequestParamsString:[self resolvedScanStartRequestJsonString:request]];
+}
+
+RCT_EXPORT_METHOD(requestScanSwitchWithScanViewConfigContentString:(NSString *)request) {
+    [ALWrapperSessionProvider requestScanSwitchWithScanViewConfigContentString:request];
+}
+
+RCT_EXPORT_METHOD(requestScanStop:(NSString * _Nullable)request) {
+    [ALWrapperSessionProvider requestScanStopWithScanStopRequestParamsString:request];
+}
+
+RCT_EXPORT_METHOD(requestUCRReport:(NSString *)request
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    self.ucrReportResolve = resolve;
+    self.ucrReportReject = reject;
+    [ALWrapperSessionProvider
+        requestUCRReportWithWrapperSessionUCRReportRequestString:request];
+}
+
+RCT_EXPORT_METHOD(requestExportCachedEvents:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    self.exportCachedEventsResolve = resolve;
+    self.exportCachedEventsReject = reject;
+    [ALWrapperSessionProvider requestExportCachedEvents];
+}
+
+-(NSString *)bundlePathFromScanViewConfigPath:(NSString * _Nullable)scanViewConfigPath {
+    // Guard against NSNull from JSON deserialization when the field is absent
+    if ([scanViewConfigPath isKindOfClass:[NSNull class]]) scanViewConfigPath = nil;
+    NSString *absoluteScanViewConfigPath = [[NSBundle mainBundle] bundlePath];
+    if (scanViewConfigPath) {
+        //append scanViewConfigPath
+        absoluteScanViewConfigPath = [absoluteScanViewConfigPath stringByAppendingPathComponent:scanViewConfigPath];
+    }
+    return absoluteScanViewConfigPath;
+}
+
+- (NSString *)resolvedScanStartRequestJsonString:(NSString *)requestJsonString {
+    if (!requestJsonString) return requestJsonString;
+    NSData *jsonData = [requestJsonString dataUsingEncoding:NSUTF8StringEncoding];
+    NSMutableDictionary *requestDict = [[NSJSONSerialization JSONObjectWithData:jsonData options:0 error:nil] mutableCopy];
+    if (!requestDict) return requestJsonString;
+    NSString *scanViewConfigPath = requestDict[@"scanViewConfigPath"];
+    requestDict[@"scanViewConfigPath"] = [self bundlePathFromScanViewConfigPath:scanViewConfigPath];
+
+    NSData *fixedData = [NSJSONSerialization dataWithJSONObject:requestDict options:0 error:nil];
+    return fixedData ? [[NSString alloc] initWithData:fixedData encoding:NSUTF8StringEncoding] : requestJsonString;
+}
+
+#pragma mark - ALWrapperSessionClientDelegate
+
+- (nullable UIViewController *)getTopViewController {
+    UIViewController *topViewController = RCTPresentedViewController();
+    if (!topViewController) {
+        for (UIScene *scene in [UIApplication sharedApplication].connectedScenes) {
+            if ([scene isKindOfClass:[UIWindowScene class]] &&
+                scene.activationState == UISceneActivationStateForegroundActive) {
+                topViewController = ((UIWindowScene *)scene).windows.firstObject.rootViewController;
+                break;
+            }
+        }
+    }
+    return topViewController;
+}
+
+- (nullable UIView *)getContainerView {
+    return [[NativeViewRegistry shared] getLastOrNull];
+}
+
+- (void)onSdkInitializationResponse:(nonnull ALWrapperSessionSDKInitializationResponse *)initializationResponse {
+    if (self.sdkInitializationResolve) {
+        NSDictionary *dict = [initializationResponse toJSONDictionary];
+        self.sdkInitializationResolve([dict asJSONString]);
+        self.sdkInitializationResolve = nil;
+        self.sdkInitializationReject = nil;
+    }
+}
+
+- (void)onScanResults:(nonnull ALWrapperSessionScanResultsResponse *)scanResultsResponse {
+    NSArray<ALExportedScanResult *> *results = (NSArray<ALExportedScanResult *> *)scanResultsResponse.exportedScanResults;
+    NSMutableArray<NSDictionary *> *resultDicts = [NSMutableArray array];
+    for (ALExportedScanResult *result in results) {
+        [resultDicts addObject:[result toJSONDictionary]];
+    }
+    NSMutableDictionary *dict = [[scanResultsResponse toJSONDictionary] mutableCopy];
+    dict[@"exportedScanResults"] = resultDicts;
+    [self sendEventWithName:kEventOnScanResults body:[dict asJSONString]];
+}
+
+- (void)onScanResponse:(nonnull ALWrapperSessionScanResponse *)scanResponse {
+    if (self.scanResponseResolve) {
+        NSDictionary *dict = [scanResponse toJSONDictionary];
+        self.scanResponseResolve([dict asJSONString]);
+        self.scanResponseResolve = nil;
+        self.scanResponseReject = nil;
+    }
+}
+
+- (void)onUIElementClicked:(nonnull ALWrapperSessionScanResultConfig *)scanResultConfig
+    uiFeedbackElementConfig:(nonnull ALUIFeedbackElementConfig *)uiFeedbackElementConfig {
+    NSDictionary *dict = [uiFeedbackElementConfig performSelector:@selector(JSONDictionary)];
+    [self sendEventWithName:kEventOnUiElementClicked body:[dict asJSONString]];
+}
+
+- (void)onUCRReportResponse:(nonnull ALWrapperSessionUCRReportResponse *)ucrReportResponse {
+    if (self.ucrReportResolve) {
+        NSDictionary *dict = [ucrReportResponse toJSONDictionary];
+        self.ucrReportResolve([dict asJSONString]);
+        self.ucrReportResolve = nil;
+        self.ucrReportReject = nil;
+    }
+}
+
+- (void)onExportCachedEventsResponse:(nonnull ALWrapperSessionExportCachedEventsResponse *)exportCachedEventsResponse {
+    if (self.exportCachedEventsResolve) {
+        NSDictionary *dict = [exportCachedEventsResponse toJSONDictionary];
+        self.exportCachedEventsResolve([dict asJSONString]);
+        self.exportCachedEventsResolve = nil;
+        self.exportCachedEventsReject = nil;
+    }
+}
+
+@end

package/ios/AnylineSDKPlugin.h

@@ -4,6 +4,7 @@
 #import <React/RCTEventEmitter.h>
 #import <React/RCTBridgeModule.h>
 
+__attribute__((deprecated("Use AnylineInfinityPlugin instead.")))
 @interface AnylineSDKPlugin : RCTEventEmitter <RCTBridgeModule, ALWrapperSessionClientDelegate>
 
 @end

package/ios/AnylineSDKPlugin.m

@@ -251,8 +251,7 @@ RCT_EXPORT_METHOD(exportCachedEvents:(RCTPromiseResolveBlock)resolve rejecter:(R
 }
 
 - (void)setupWrapperSessionWithPluginVersion:(NSString *)pluginVersion {
-    // Setup wrapper session with this view controller as delegate
-    ALWrapperConfig *wrapperConfig = [ALWrapperConfig reactNative:pluginVersion];
+    ALWrapperConfig *wrapperConfig = [ALWrapperConfig reactNative:pluginVersion codename:ALWrapperCodenameLegacy];
     [ALWrapperSessionProvider setupWrapperSessionWithWrapperInfo:wrapperConfig
                                             wrapperSessionClient:self];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyline-ocr-react-native-module",
-  "version": "55.9.0",
+  "version": "56.0.0",
   "description": "A Plugin for connecting Anyline with React-Native",
   "keywords": [
     "reactnative",