React Native 0.76 JSI vs Flutter Platform Channels: calling a native barcode scanner 1000 times

// js/BarCodeScannerJsiModule.js
// React Native 0.76 JSI module for native barcode scanning
// Requires react-native 0.76.0+, iOS 14+/Android 8+, Hermes 0.76+
import { NativeModules, Platform } from 'react-native';
import type { BarCodeType } from './types';

// JSI-injected native function reference (populated at runtime)
let jsiScanBarCode: ((options: {
  cameraId?: string;
  scanTimeoutMs?: number;
  allowedTypes?: BarCodeType[];
}) => Promise<{
  rawValue: string;
  type: BarCodeType;
  timestampMs: number;
}>) | null = null;

// Initialize JSI bridge (called once at app startup, e.g., in App.tsx)
export const initBarCodeJsi = (): void => {
  if (Platform.OS === 'ios') {
    // iOS JSI injection: access global native object injected via Obj-C++ bridge
    if ((global as any).barCodeScannerJsi) {
      jsiScanBarCode = (global as any).barCodeScannerJsi.scan;
      console.log('JSI BarCode module initialized on iOS');
    } else {
      console.warn('JSI BarCode module not injected on iOS. Falling back to legacy bridge.');
      jsiScanBarCode = null;
    }
  } else if (Platform.OS === 'android') {
    // Android JSI injection: access JSI global injected via C++ bridge
    if ((global as any).BarCodeScannerJsiModule) {
      jsiScanBarCode = (global as any).BarCodeScannerJsiModule.scan;
      console.log('JSI BarCode module initialized on Android');
    } else {
      console.warn('JSI BarCode module not injected on Android. Falling back to legacy bridge.');
      jsiScanBarCode = null;
    }
  } else {
    throw new Error(`Unsupported platform: ${Platform.OS}`);
  }
};

// Scan barcode using JSI (falls back to legacy if JSI unavailable)
export const scanBarCodeJsi = async (options: {
  cameraId?: string;
  scanTimeoutMs?: number;
  allowedTypes?: BarCodeType[];
} = {}): Promise<{
  rawValue: string;
  type: BarCodeType;
  timestampMs: number;
}> => {
  // Validate inputs to prevent invalid native calls
  if (options.scanTimeoutMs && options.scanTimeoutMs < 100) {
    throw new Error('scanTimeoutMs must be ≥ 100ms to prevent camera timeout');
  }
  if (options.allowedTypes && !Array.isArray(options.allowedTypes)) {
    throw new Error('allowedTypes must be an array of BarCodeType enums');
  }

  // Use JSI if available (3-5x faster than legacy bridge)
  if (jsiScanBarCode) {
    try {
      const result = await jsiScanBarCode({
        cameraId: options.cameraId || 'default',
        scanTimeoutMs: options.scanTimeoutMs || 5000,
        allowedTypes: options.allowedTypes || ['QR_CODE', 'CODE_128'],
      });
      // Validate native response to catch malformed data early
      if (!result.rawValue || typeof result.rawValue !== 'string') {
        throw new Error('Invalid native response: missing or invalid rawValue');
      }
      if (!result.type || typeof result.type !== 'string') {
        throw new Error('Invalid native response: missing or invalid type');
      }
      return result;
    } catch (err) {
      console.error('JSI scan failed, falling back to legacy bridge:', err);
      // Fallback to legacy NativeModules bridge if JSI call fails
      return NativeModules.BarCodeScannerModule.scan(options);
    }
  } else {
    // Fallback to legacy bridge if JSI not initialized
    console.log('Using legacy bridge for barcode scan');
    return NativeModules.BarCodeScannerModule.scan(options);
  }
};

// Cleanup JSI references (call on app tear down to prevent memory leaks)
export const cleanupBarCodeJsi = (): void => {
  jsiScanBarCode = null;
  console.log('JSI BarCode module cleaned up');
};

// lib/bar_code_scanner_channel.dart
// Flutter Platform Channels implementation for native barcode scanning
// Requires Flutter 3.24.3+, iOS 14+/Android 8+, camera plugin 0.10.0+
import 'dart:async';
import 'dart:io';
import 'package:flutter/services.dart';

enum BarCodeType { qrCode, code128, ean13, upcA, dataMatrix }

class BarCodeScanResult {
  final String rawValue;
  final BarCodeType type;
  final int timestampMs;
  final Map? metadata;

  BarCodeScanResult({
    required this.rawValue,
    required this.type,
    required this.timestampMs,
    this.metadata,
  });

  factory BarCodeScanResult.fromMap(Map map) {
    return BarCodeScanResult(
      rawValue: map['rawValue'] as String,
      type: BarCodeType.values.firstWhere(
        (e) => e.name == (map['type'] as String),
        orElse: () => BarCodeType.qrCode,
      ),
      timestampMs: map['timestampMs'] as int,
      metadata: map['metadata'] as Map?,
    );
  }
}

class BarCodeScannerChannel {
  // Platform Channel name must match native iOS/Android implementation exactly
  static const MethodChannel _channel = MethodChannel('com.example.barcode_scanner');

  // Scan barcode via Platform Channel (async, as all Platform Channels are)
  static Future scan({
    String cameraId = 'default',
    int scanTimeoutMs = 5000,
    List allowedTypes = const [BarCodeType.qrCode, BarCodeType.code128],
  }) async {
    // Validate inputs to prevent invalid native calls
    if (scanTimeoutMs < 100) {
      throw ArgumentError('scanTimeoutMs must be ≥ 100ms to prevent camera timeout');
    }
    if (allowedTypes.isEmpty) {
      throw ArgumentError('allowedTypes cannot be empty: specify at least one barcode type');
    }

    try {
      // Invoke native method via Platform Channel, pass arguments as map
      final Map? result = await _channel.invokeMethod>(
        'scanBarCode',
        {
          'cameraId': cameraId,
          'scanTimeoutMs': scanTimeoutMs,
          'allowedTypes': allowedTypes.map((e) => e.name).toList(),
          'returnMetadata': true,
        },
      );

      if (result == null) {
        throw PlatformException(
          code: 'NULL_RESPONSE',
          message: 'Native scan returned null response',
          details: {'cameraId': cameraId},
        );
      }

      return BarCodeScanResult.fromMap(result);
    } on PlatformException catch (e) {
      // Handle native platform errors (e.g., camera permission denied)
      throw Exception('Platform scan failed: ${e.code} - ${e.message ?? 'No message'}');
    } on TypeError catch (e) {
      // Handle invalid response type from native side
      throw Exception('Invalid native response format: $e');
    } catch (e) {
      // Handle unexpected errors (e.g., network issues, runtime errors)
      throw Exception('Unexpected scan error: $e');
    }
  }

  // Check if native scanner hardware is available (e.g., camera exists)
  static Future isScannerAvailable() async {
    try {
      final bool? available = await _channel.invokeMethod('isScannerAvailable');
      return available ?? false;
    } on PlatformException catch (e) {
      print('Scanner availability check failed: ${e.code}');
      return false;
    }
  }

  // Cancel an in-progress scan (if supported by native SDK)
  static Future cancelScan() async {
    try {
      await _channel.invokeMethod('cancelScan');
    } on PlatformException catch (e) {
      print('Cancel scan failed: ${e.code}');
    }
  }
}

// ios/BarCodeScannerJsi.mm
// Objective-C++ JSI binding for iOS barcode scanner (React Native 0.76)
// Requires Xcode 15.4+, iOS 17.4+, react-native 0.76.0+, Hermes 0.76+
#import 
#import 
#import 
#import 
#import 
#import "BarCodeScannerJsi.h"
#import "BarCodeScannerNative.h" // Native scanner implementation (uses AVFoundation)

using namespace facebook::jsi;

@implementation BarCodeScannerJsi

RCT_EXPORT_MODULE()

// Install JSI bindings when bridge is initialized
- (void)setBridge:(RCTBridge *)bridge {
  [super setBridge:bridge];
  [self installJsiBindings:bridge];
}

- (void)installJsiBindings:(RCTBridge *)bridge {
  // Get C++ JSI runtime from React Native bridge
  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)bridge;
  if (!cxxBridge.runtime) {
    RCTLogError(@"JSI runtime not available: ensure Hermes is enabled in Podfile");
    return;
  }

  Runtime &runtime = *(jsi::Runtime *)cxxBridge.runtime;

  // Define global JSI object: barCodeScannerJsi
  Object jsiModule = Object(runtime);

  // Define scan function on JSI module (host function callable from JS)
  jsiModule.setProperty(
    runtime,
    "scan",
    Function::createFromHostFunction(
      runtime,
      PropNameID::forAscii(runtime, "scan"),
      1, // number of arguments expected from JS
      [self](Runtime &runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value {
        // Validate arguments: first argument must be an options object
        if (count < 1 || !arguments[0].isObject()) {
          throw JSError(runtime, "scan requires an options object as first argument");
        }

        Object options = arguments[0].asObject(runtime);

        // Parse cameraId from options (default to "default")
        std::string cameraId = "default";
        if (options.hasProperty(runtime, "cameraId")) {
          cameraId = options.getProperty(runtime, "cameraId").asString(runtime).utf8(runtime);
        }

        // Parse scanTimeoutMs from options (default to 5000ms)
        int scanTimeoutMs = 5000;
        if (options.hasProperty(runtime, "scanTimeoutMs")) {
          scanTimeoutMs = (int)options.getProperty(runtime, "scanTimeoutMs").asNumber();
        }

        // Parse allowedTypes from options (default to QR_CODE, CODE_128)
        NSArray *allowedTypes = @[@"QR_CODE", @"CODE_128"];
        if (options.hasProperty(runtime, "allowedTypes")) {
          Value allowedTypesValue = options.getProperty(runtime, "allowedTypes");
          if (allowedTypesValue.isArray(runtime)) {
            Array allowedTypesArray = allowedTypesValue.asArray(runtime);
            NSMutableArray *types = [NSMutableArray array];
            for (size_t i = 0; i < allowedTypesArray.size(runtime); i++) {
              std::string typeStr = allowedTypesArray.getValueAtIndex(runtime, i).asString(runtime).utf8(runtime);
              [types addObject:[NSString stringWithUTF8String:typeStr.c_str()]];
            }
            allowedTypes = types;
          }
        }

        // Call native scanner (synchronous, as JSI supports sync calls)
        NSError *error = nil;
        BarCodeScanResult *result = [BarCodeScannerNative scanWithCameraId:[NSString stringWithUTF8String:cameraId.c_str()]
                                                               timeoutMs:scanTimeoutMs
                                                             allowedTypes:allowedTypes
                                                                   error:&error];

        if (error) {
          throw JSError(runtime, [error.localizedDescription UTF8String]);
        }

        if (!result) {
          throw JSError(runtime, "Native scanner returned nil result");
        }

        // Convert native result to JSI object to return to JS
        Object jsiResult = Object(runtime);
        jsiResult.setProperty(runtime, "rawValue", String::createFromUtf8(runtime, result.rawValue.UTF8String));
        jsiResult.setProperty(runtime, "type", String::createFromUtf8(runtime, result.type.UTF8String));
        jsiResult.setProperty(runtime, "timestampMs", (double)result.timestampMs);

        // Add metadata if available
        if (result.metadata) {
          Object metadataObj = Object(runtime);
          for (NSString *key in result.metadata) {
            NSString *value = result.metadata[key];
            metadataObj.setProperty(runtime, [key UTF8String], String::createFromUtf8(runtime, value.UTF8String));
          }
          jsiResult.setProperty(runtime, "metadata", metadataObj);
        }

        return jsiResult;
      }
    )
  );

  // Inject JSI module into global JavaScript scope
  runtime.global().setProperty(runtime, "barCodeScannerJsi", jsiModule);
  RCTLogInfo(@"JSI BarCode module installed successfully");
}

- (void)invalidate {
  // Cleanup JSI bindings when module is invalidated (app tear down)
  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
  if (cxxBridge.runtime) {
    Runtime &runtime = *(jsi::Runtime *)cxxBridge.runtime;
    runtime.global().deleteProperty(runtime, "barCodeScannerJsi");
    RCTLogInfo(@"JSI BarCode module cleaned up");
  }
  [super invalidate];
}

@end

// Benchmark utility to measure bridge latency
export const benchmarkBridge = async (scanFn: () => Promise, iterations: number = 1000) => {
  const latencies: number[] = [];
  const start = Date.now();
  for (let i = 0; i < iterations; i++) {
    const callStart = Date.now();
    await scanFn();
    latencies.push(Date.now() - callStart);
  }
  const totalTime = Date.now() - start;
  return {
    p50: latencies.sort((a,b) => a-b)[Math.floor(iterations * 0.5)],
    p99: latencies.sort((a,b) => a-b)[Math.floor(iterations * 0.99)],
    throughput: (iterations / totalTime) * 1000,
  };
};

// Fallback logic for JSI unavailability
const scanWithFallback = async (options: ScanOptions) => {
  if (jsiScanBarCode) {
    try {
      return await jsiScanBarCode(options);
    } catch (err) {
      console.error('JSI failed, falling back to legacy:', err);
    }
  }
  return NativeModules.BarCodeScannerModule.scan(options);
};

// Protobuf serialization for Platform Channels
import 'package:protobuf/protobuf.dart';

class BarCodeScanRequest extends GeneratedMessage {
  // Protobuf field definitions
  string cameraId = 1;
  int32 scanTimeoutMs = 2;
  repeated string allowedTypes = 3;
}

// Send protobuf request over Platform Channel
final request = BarCodeScanRequest()
  ..cameraId = 'default'
  ..scanTimeoutMs = 5000
  ..allowedTypes.addAll(['QR_CODE', 'CODE_128']);
final result = await _channel.invokeMethod('scanBarCode', request.writeToBuffer());