如何在React Native 0.71.4中连接并读取Zebra RFD90 Reader数据？

方案一：使用Zebra官方SDK（推荐，适配性更好） #

Zebra针对RFID阅读器提供了专属SDK，分别支持Android和iOS平台，需通过React Native原生模块桥接调用。

Android端实现 #

1. 集成Zebra EMDK SDK

   • 在项目级build.gradle中添加Zebra Maven仓库：

     allprojects {
         repositories {
             maven { url "https://zebratech.jfrog.io/artifactory/emdk-android/" }
         }
     }
     

   • 在app级build.gradle添加依赖：

     dependencies {
         implementation 'com.symbol.emdk:emdk:11.4.0'
     }
     

   • 在AndroidManifest.xml添加权限和EMDK配置：

     <uses-permission android:name="android.permission.BLUETOOTH" />
     <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <!-- EMDK配置 -->
     <meta-data android:name="com.symbol.emdk.permission.REQUIRED" android:value="true" />
     <activity android:name="com.symbol.emdk.EMDKActivity" />
     

2. 编写原生桥接模块

   • 创建Java类实现ReactContextBaseJavaModule，封装EMDK扫描逻辑：

     public class ZebraRfidModule extends ReactContextBaseJavaModule implements EMDKManager.EMDKListener {
         private EMDKManager emdkManager;
         private RFIDManager rfidManager;
         private Reader reader;
     
         public ZebraRfidModule(ReactApplicationContext reactContext) {
             super(reactContext);
         }
     
         @Override
         public String getName() {
             return "ZebraRfid";
         }
     
         @ReactMethod
         public void connectReader(Promise promise) {
             EMDKResults results = EMDKManager.getEMDKManager(getReactApplicationContext(), this);
             if (results.statusCode == EMDKResults.STATUS_CODE.SUCCESS) {
                 promise.resolve("EMDK初始化成功");
             } else {
                 promise.reject("INIT_FAILED", "EMDK初始化失败");
             }
         }
     
         @ReactMethod
         public void startScanning(Promise promise) {
             if (reader != null) {
                 try {
                     reader.startReading();
                     promise.resolve("扫描已启动");
                 } catch (RFIDReaderException e) {
                     promise.reject("SCAN_FAILED", e.getMessage());
                 }
             } else {
                 promise.reject("NO_READER", "未连接阅读器");
             }
         }
     
         @Override
         public void onOpened(EMDKManager emdkManager) {
             this.emdkManager = emdkManager;
             rfidManager = (RFIDManager) emdkManager.getInstance(EMDKManager.FEATURE_TYPE.RFID);
             if (rfidManager != null) {
                 List<ReaderDevice> devices = rfidManager.getSupportedDevices();
                 for (ReaderDevice device : devices) {
                     if (device.getDeviceType() == ReaderDevice.DeviceType.BLUETOOTH) {
                         try {
                             reader = rfidManager.createReader(device);
                             reader.connect();
                             reader.addReaderListener(new Reader.ReaderListener() {
                                 @Override
                                 public void onRead(ReadData readData) {
                                     List<TagData> tags = readData.getTags();
                                     for (TagData tag : tags) {
                                         getReactApplicationContext()
                                             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                                             .emit("onTagScanned", tag.getTagID());
                                     }
                                 }
     
                                 @Override
                                 public void onReaderException(RFIDReaderException e) {}
                             });
                         } catch (RFIDReaderException e) {
                             e.printStackTrace();
                         }
                     }
                 }
             }
         }
     
         @Override
         public void onClosed() {
             if (reader != null) {
                 try {
                     reader.disconnect();
                 } catch (RFIDReaderException e) {
                     e.printStackTrace();
                 }
             }
             if (emdkManager != null) {
                 emdkManager.release();
             }
         }
     }
     

   • 创建ReactPackage类注册该模块，添加到MainApplication.java的getPackages()列表中。

3. React Native端调用

   import { NativeModules, NativeEventEmitter, useEffect } from 'react-native';
   
   const { ZebraRfid } = NativeModules;
   const zebraRfidEmitter = new NativeEventEmitter(ZebraRfid);
   
   const connectReader = async () => {
       try {
           await ZebraRfid.connectReader();
           console.log('阅读器连接成功');
       } catch (error) {
           console.error('连接失败:', error);
       }
   };
   
   const startScanning = async () => {
       try {
           await ZebraRfid.startScanning();
       } catch (error) {
           console.error('启动扫描失败:', error);
       }
   };
   
   useEffect(() => {
       const subscription = zebraRfidEmitter.addListener('onTagScanned', (tagId) => {
           console.log('扫描到标签:', tagId);
           // 处理标签数据
       });
       return () => subscription.remove();
   }, []);
   

iOS端实现 #

1. 集成Zebra RFID SDK

   • 在Podfile添加依赖：

     pod 'ZebraRfidSdk', '~> 2.0'
     

   • 执行pod install安装SDK，在Info.plist添加蓝牙权限：

     <key>NSBluetoothAlwaysUsageDescription</key>
     <string>需要蓝牙权限连接Zebra阅读器</string>
     <key>NSBluetoothPeripheralUsageDescription</key>
     <string>需要蓝牙权限连接Zebra阅读器</string>
     

2. 编写原生桥接模块

   • 创建Swift类封装SDK逻辑：

     import React
     import ZebraRfidSdk
     
     @objc(ZebraRfidModule)
     class ZebraRfidModule: NSObject, RCTBridgeModule, RFIDReaderDelegate {
         var reader: RFIDReader?
         var bridge: RCTBridge!
     
         static func moduleName() -> String { "ZebraRfid" }
         static func requiresMainQueueSetup() -> Bool { true }
     
         @objc func connectReader(_ resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) {
             RFIDReader.sharedInstance().delegate = self
             RFIDReader.sharedInstance().startScanForReaders()
             resolve("开始扫描阅读器")
         }
     
         @objc func startScanning(_ resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) {
             guard let reader = reader else {
                 reject("NO_READER", "未连接阅读器", nil)
                 return
             }
             do {
                 try reader.startReading()
                 resolve("扫描已启动")
             } catch {
                 reject("SCAN_FAILED", error.localizedDescription, error)
             }
         }
     
         func readerDidConnect(_ reader: RFIDReader) {
             self.reader = reader
             bridge.eventDispatcher().sendAppEvent(withName: "onReaderConnected", body: nil)
         }
     
         func reader(_ reader: RFIDReader, didReadTags tags: [RFIDTag]) {
             tags.forEach { tag in
                 bridge.eventDispatcher().sendAppEvent(withName: "onTagScanned", body: tag.tagID)
             }
         }
     }
     

   • 创建Swift桥接文件，在AppDelegate.m中注册模块。

3. React Native端调用

   import { NativeModules, NativeEventEmitter, useEffect } from 'react-native';
   
   const { ZebraRfidModule } = NativeModules;
   const zebraRfidEmitter = new NativeEventEmitter(ZebraRfidModule);
   
   useEffect(() => {
       const connectSub = zebraRfidEmitter.addListener('onReaderConnected', () => {
           console.log('阅读器已连接');
           startScanning();
       });
       const tagSub = zebraRfidEmitter.addListener('onTagScanned', (tagId) => {
           console.log('扫描到标签:', tagId);
       });
       return () => {
           connectSub.remove();
           tagSub.remove();
       };
   }, []);
   
   const connectReader = async () => {
       try {
           await ZebraRfidModule.connectReader();
       } catch (error) {
           console.error('连接失败:', error);
       }
   };
   

方案二：使用通用BLE库（备选，无官方支持） #

若不想做原生桥接，可尝试react-native-ble-plx，但需自行查询Zebra RFD90的BLE服务/特征UUID并解析数据。

1. 安装依赖

   npm install react-native-ble-plx
   

2. 扫描连接与数据监听

   import { BleManager } from 'react-native-ble-plx';
   
   const manager = new BleManager();
   
   const scanDevices = () => {
       manager.startDeviceScan(null, null, (error, device) => {
           if (error) {
               console.error(error);
               return;
           }
           if (device.name?.includes('Zebra RFD90')) {
               manager.stopDeviceScan();
               connectToDevice(device.id);
           }
       });
   };
   
   const connectToDevice = async (deviceId) => {
       try {
           const device = await manager.connectToDevice(deviceId);
           await device.discoverAllServicesAndCharacteristics();
           const service = await device.serviceForUUID('替换为RFD90的服务UUID');
           const characteristic = await service.characteristicForUUID('替换为RFD90的特征UUID');
           characteristic.monitor((error, char) => {
               if (error) {
                   console.error(error);
                   return;
               }
               const tagData = new TextDecoder().decode(char.value);
               console.log('扫描到标签:', tagData);
           });
       } catch (error) {
           console.error('连接失败:', error);
       }
   };
   

注意事项 #

• 确保设备已通过蓝牙配对到手机。
• Android 12+需额外添加BLUETOOTH_SCAN和BLUETOOTH_CONNECT权限并动态申请。
• iOS需正确配置Info.plist蓝牙权限描述，避免被App Store拒绝。
• 测试需使用真实设备，模拟器不支持蓝牙功能。

内容的提问来源于stack exchange，提问作者ijaz bacha