@onekeyfe/react-native-lite-card 3.0.146 → 3.0.148

package/ios/Classes/OKNFTLite/OKNFCManager.m

@@ -40,6 +40,9 @@
 @property (nonatomic, strong) OKLiteV1 *lite;
 
 @property (nonatomic, strong) NSMutableDictionary *completionBlocks;
+// CoreNFC reports the app's own invalidateSession with the same code as a user
+// cancel, so the invalidation callback has to know who ended the session.
+@property (atomic, assign) BOOL sessionEndedByApp;
 
 @end
 
@@ -58,6 +61,7 @@
 
 
 - (void)endNFCSessionWithError:(BOOL)isError {
+    self.sessionEndedByApp = YES;
     self.session.alertMessage = @"";
     if (isError) {
         [self.session invalidateSessionWithErrorMessage:OKTools.isChineseLan ? @"读取失败，请重试":@"Connect fail, please try again."];
@@ -75,7 +79,66 @@
     return _completionBlocks;
 }
 
+// The card operation and the session invalidation run on different threads of
+// the delegate queue and can both try to finish the same request, e.g. when the
+// user cancels while the card is being read. Only the first caller gets the
+// completion: React Native aborts the app when a callback runs twice.
+- (id)takeCompletionForKey:(NSString *)key {
+    id completion = nil;
+    @synchronized (self) {
+        completion = [_completionBlocks objectForKey:key];
+        [_completionBlocks removeObjectForKey:key];
+    }
+    if (!completion) {
+        [LCLogger debug:[NSString stringWithFormat:@"%@ already finished, dropping the late result", key]];
+    }
+    return completion;
+}
+
+// Finishes the pending request when the session ends before the card operation
+// reports its own result: as a cancel when the user or system ended the session,
+// otherwise as a connection failure.
+- (void)finishPendingRequestAsCancel:(BOOL)asCancel sessionError:(NSError *)sessionError {
+    switch (self.sessionType) {
+        case OKNFCLiteSessionTypeGetInfo:
+        case OKNFCLiteSessionTypeUpdateInfo:{
+            GetLiteInfoCallback callback = [self takeCompletionForKey:kGetLiteInfoBlock];
+            if (callback) {
+                callback(nil, OKNFCLiteStatusError);
+            }
+        } break;
+        case OKNFCLiteSessionTypeReset: {
+            ResetCallback callback = [self takeCompletionForKey:kResetBlock];
+            if (callback) {
+                callback(self.lite, NO, sessionError);
+            }
+        } break;
+        case OKNFCLiteSessionTypeSetMnemonic:
+        case OKNFCLiteSessionTypeSetMnemonicForce: {
+            SetMnemonicCallback callback = [self takeCompletionForKey:kSetMnemonicBlock];
+            if (callback) {
+                callback(self.lite, asCancel ? OKNFCLiteSetMncStatusCancel : OKNFCLiteSetMncStatusError);
+            }
+        } break;
+        case OKNFCLiteSessionTypeGetMnemonic: {
+            GetMnemonicCallback callback = [self takeCompletionForKey:kGetMnemonicBlock];
+            if (callback) {
+                callback(self.lite, nil, asCancel ? OKNFCLiteGetMncStatusCancel : OKNFCLiteGetMncStatusError);
+            }
+        } break;
+        case OKNFCLiteSessionTypeChangePin: {
+            ChangePinCallback callback = [self takeCompletionForKey:kChangePinBlock];
+            if (callback) {
+                callback(self.lite, asCancel ? OKNFCLiteChangePinStatusCancel : OKNFCLiteChangePinStatusError);
+            }
+        } break;
+        default:
+            break;
+    }
+}
+
 - (void)beginNewNFCSession {
+    self.sessionEndedByApp = NO;
     self.session = [[NFCTagReaderSession alloc] initWithPollingOption:NFCPollingISO14443 delegate:self queue:dispatch_get_global_queue(2, 0)];
     [self.session beginSession];
 }
@@ -94,6 +157,7 @@
             [LCLogger error:errMsg];
             //            [kTools debugTipMessage:errMsg];
             [self endNFCSessionWithError:YES];
+            [self finishPendingRequestAsCancel:NO sessionError:nil];
             return;
         }
         [self nfcSessionComplete:session];
@@ -102,44 +166,10 @@
 
 - (void)tagReaderSession:(NFCTagReaderSession *)session didInvalidateWithError:(NSError *)error {
     [LCLogger debug:[NSString stringWithFormat:@"tagReaderSession didInvalidateWithError: %@", error.localizedDescription]];
-    if (error.code == 200 || error.code == 6) {
-        switch (self.sessionType) {
-            case OKNFCLiteSessionTypeGetInfo:
-            case OKNFCLiteSessionTypeUpdateInfo:{
-                GetLiteInfoCallback callback = [_completionBlocks objectForKey:kGetLiteInfoBlock];
-                if(callback) {
-                    callback(nil,OKNFCLiteStatusError);
-                }
-            } break;
-            case OKNFCLiteSessionTypeReset: {
-                ResetCallback callback = [_completionBlocks objectForKey:kResetBlock];
-                if (callback) {
-                    callback(self.lite, NO,error);
-                }
-            } break;
-            case OKNFCLiteSessionTypeSetMnemonic:
-            case OKNFCLiteSessionTypeSetMnemonicForce: {
-                SetMnemonicCallback callback = [_completionBlocks objectForKey:kSetMnemonicBlock];
-                if (callback) {
-                    callback(self.lite,OKNFCLiteSetMncStatusCancel);
-                }
-            } break;
-            case OKNFCLiteSessionTypeGetMnemonic: {
-                GetMnemonicCallback callback = [_completionBlocks objectForKey:kGetMnemonicBlock];
-                if (callback) {
-                    callback(self.lite,nil,OKNFCLiteGetMncStatusCancel);
-                }
-            } break;
-            case OKNFCLiteSessionTypeChangePin: {
-                ChangePinCallback callback = [_completionBlocks objectForKey:kChangePinBlock];
-                if (callback) {
-                    callback(self.lite,OKNFCLiteChangePinStatusCancel);
-                }
-
-            } break;
-            default:
-                break;
-        }
+    // When the app ended the session, the card operation that ended it reports
+    // the real result; treating this as a cancel would race with it.
+    if ((error.code == 200 || error.code == 6) && !self.sessionEndedByApp) {
+        [self finishPendingRequestAsCancel:YES sessionError:error];
     }
     [session invalidateSession];
 }
@@ -153,6 +183,9 @@
 - (void)nfcSessionComplete:(NFCTagReaderSession *)session {
     if (![self checkLiteVersion]) {
         [self endNFCSessionWithError:YES];
+        [self finishPendingRequestAsCancel:NO sessionError:nil];
+        self.sessionType = OKNFCLiteSessionTypeNone;
+        return;
     }
     self.selectNFCApp = OKNFCLiteAppNONE;
     switch (self.sessionType) {
@@ -205,8 +238,13 @@
 }
 
 - (void)_getLiteInfo {
-    GetLiteInfoCallback callback = [_completionBlocks objectForKey:kGetLiteInfoBlock];
-    [self.lite getLiteInfo:callback];
+    __weak typeof(self) weakSelf = self;
+    [self.lite getLiteInfo:^(OKLiteV1 *lite, OKNFCLiteStatus status) {
+        GetLiteInfoCallback callback = [weakSelf takeCompletionForKey:kGetLiteInfoBlock];
+        if (callback) {
+            callback(lite, status);
+        }
+    }];
 }
 
 - (BOOL)syncLiteInfo {
@@ -237,13 +275,18 @@
 }
 
 - (void)_setMnemonic:(BOOL)force {
-    SetMnemonicCallback callback = [_completionBlocks objectForKey:kSetMnemonicBlock];
     NSString *mnemonic = self.exportMnemonic;
     NSString *pin = self.pin;
     // Clear sensitive data from properties immediately
     self.exportMnemonic = nil;
     self.pin = nil;
-    [self.lite setMnemonic:mnemonic withPin:pin overwrite:force complete:callback];
+    __weak typeof(self) weakSelf = self;
+    [self.lite setMnemonic:mnemonic withPin:pin overwrite:force complete:^(OKLiteV1 *lite, OKNFCLiteSetMncStatus status) {
+        SetMnemonicCallback callback = [weakSelf takeCompletionForKey:kSetMnemonicBlock];
+        if (callback) {
+            callback(lite, status);
+        }
+    }];
 }
 
 #pragma mark - getMnemonic
@@ -259,11 +302,16 @@
 }
 
 - (void)_getMnemonic {
-    GetMnemonicCallback callback = [_completionBlocks objectForKey:kGetMnemonicBlock];
     NSString *pin = self.pin;
     // Clear sensitive data from property immediately
     self.pin = nil;
-    [self.lite getMnemonicWithPin:pin complete:callback];
+    __weak typeof(self) weakSelf = self;
+    [self.lite getMnemonicWithPin:pin complete:^(OKLiteV1 *lite, NSString *mnemonic, OKNFCLiteGetMncStatus status) {
+        GetMnemonicCallback callback = [weakSelf takeCompletionForKey:kGetMnemonicBlock];
+        if (callback) {
+            callback(lite, mnemonic, status);
+        }
+    }];
 }
 
 #pragma mark - changePin
@@ -277,13 +325,18 @@
 }
 
 - (void)_changePin {
-    ChangePinCallback callback = [_completionBlocks objectForKey:kChangePinBlock];
     NSString *oldPin = self.pin;
     NSString *newPin = self.neoPin;
     // Clear sensitive data from properties immediately
     self.pin = nil;
     self.neoPin = nil;
-    [self.lite changePin:oldPin to:newPin complete:callback];
+    __weak typeof(self) weakSelf = self;
+    [self.lite changePin:oldPin to:newPin complete:^(OKLiteV1 *lite, OKNFCLiteChangePinStatus status) {
+        ChangePinCallback callback = [weakSelf takeCompletionForKey:kChangePinBlock];
+        if (callback) {
+            callback(lite, status);
+        }
+    }];
 }
 
 #pragma mark - reset
@@ -295,8 +348,13 @@
 }
 
 - (void)_reset {
-    ResetCallback callback = [_completionBlocks objectForKey:kResetBlock];
-    [self.lite reset:callback];
+    __weak typeof(self) weakSelf = self;
+    [self.lite reset:^(OKLiteV1 *lite, BOOL isSuccess, NSError *error) {
+        ResetCallback callback = [weakSelf takeCompletionForKey:kResetBlock];
+        if (callback) {
+            callback(lite, isSuccess, error);
+        }
+    }];
 }
 
 - (BOOL)_resetSync {

package/ios/ReactNativeLiteCard.mm

@@ -5,6 +5,9 @@
 #import "OKLiteV1.h"
 #import "LCLogger.h"
 
+#include <atomic>
+#include <memory>
+
 typedef NS_ENUM(NSInteger, NFCLiteExceptions) {
   NFCLiteExceptionsInitChannel = 1000,// 初始化异常
   NFCLiteExceptionsNotExistsNFC = 1001,// 没有 NFC 设备
@@ -25,6 +28,20 @@ typedef NS_ENUM(NSInteger, NFCLiteExceptions) {
   NFCLiteExceptionsNotInitialized = 4002,// 没有备份过内容
 };
 
+// React Native aborts the app when a callback runs twice, and NFC results can
+// arrive from more than one CoreNFC thread, so only the first result is sent.
+static RCTResponseSenderBlock OKLiteCallbackOnce(RCTResponseSenderBlock callback)
+{
+  auto invoked = std::make_shared<std::atomic<bool>>(false);
+  return ^(NSArray *response) {
+    if (invoked->exchange(true)) {
+      [LCLogger warn:@"Dropped a repeated Lite card callback"];
+      return;
+    }
+    callback(response);
+  };
+}
+
 @implementation ReactNativeLiteCard
 - (NSNumber *)multiply:(double)a b:(double)b {
     NSNumber *result = @(a * b);
@@ -57,6 +74,7 @@ typedef NS_ENUM(NSInteger, NFCLiteExceptions) {
 
 - (void)getLiteInfo:(RCTResponseSenderBlock)callBack
 {
+  callBack = OKLiteCallbackOnce(callBack);
   if ([ReactNativeLiteCard checkSDKVaild:callBack]) {
     __block OKNFCManager *liteManager = [[OKNFCManager alloc] init];
     [liteManager getLiteInfo:^(OKLiteV1 *lite, OKNFCLiteStatus status) {
@@ -74,6 +92,7 @@ typedef NS_ENUM(NSInteger, NFCLiteExceptions) {
 
 - (void)setMnemonic:(NSString *)mnemonic pwd:(NSString *)pwd overwrite:(BOOL)overwrite callback:(RCTResponseSenderBlock)callBack
 {
+  callBack = OKLiteCallbackOnce(callBack);
   if ([ReactNativeLiteCard checkSDKVaild:callBack]) {
     __block OKNFCManager *liteManager = [[OKNFCManager alloc] init];
     [liteManager setMnemonic:mnemonic withPin:pwd overwrite:overwrite complete:^(OKLiteV1 *lite, OKNFCLiteSetMncStatus status) {
@@ -111,6 +130,7 @@ typedef NS_ENUM(NSInteger, NFCLiteExceptions) {
 
 - (void)getMnemonicWithPin:(NSString *)pwd callback:(RCTResponseSenderBlock)callBack
 {
+  callBack = OKLiteCallbackOnce(callBack);
   if ([ReactNativeLiteCard checkSDKVaild:callBack]) {
     __block OKNFCManager *liteManager = [[OKNFCManager alloc] init];
     [liteManager getMnemonicWithPin:pwd complete:^(OKLiteV1 *lite, NSString *mnemonic, OKNFCLiteGetMncStatus status) {
@@ -150,6 +170,7 @@ typedef NS_ENUM(NSInteger, NFCLiteExceptions) {
 
 - (void)changePin:(NSString *)oldPin newPin:(NSString *)newPin callback:(RCTResponseSenderBlock)callBack
 {
+  callBack = OKLiteCallbackOnce(callBack);
   if ([ReactNativeLiteCard checkSDKVaild:callBack]) {
     __block OKNFCManager *liteManager = [[OKNFCManager alloc] init];
     [liteManager changePin:oldPin to:newPin complete:^(OKLiteV1 *lite, OKNFCLiteChangePinStatus status) {
@@ -183,6 +204,7 @@ typedef NS_ENUM(NSInteger, NFCLiteExceptions) {
 
 - (void)reset:(RCTResponseSenderBlock)callBack
 {
+  callBack = OKLiteCallbackOnce(callBack);
   if ([ReactNativeLiteCard checkSDKVaild:callBack]) {
     __block OKNFCManager *liteManager = [[OKNFCManager alloc] init];
     [liteManager reset:^(OKLiteV1 *lite, BOOL isSuccess, NSError *error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-lite-card",
-  "version": "3.0.146",
+  "version": "3.0.148",
   "description": "lite card",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",