react-native-nfc-manager 4.0.0-beta.7 → 4.0.0-beta.8

package/ios/RNNfcManager+IsoDep.swift

@@ -0,0 +1,145 @@
+import CoreNFC
+import Foundation
+
+public extension RNNfcManager {
+    @objc(sendCommandAPDUBytes:callback:)
+    static func sendCommandAPDUBytes(
+        _ bytes: [NSNumber],
+        callback: @escaping RNNfcResponseSenderBlock
+    ) {
+        forwardWithTagSessionSupport(
+            isTagSessionSupported(),
+            callback: callback,
+            operation: { tagSession in
+                sendCommandAPDUBytes(with: tagSession, bytes: bytes) { response, sw1, sw2, error in
+                    if let error {
+                        callback([RNNfcSwiftUtil.errorMessage(from: error as NSError), NSNull()])
+                        return
+                    }
+
+                    callback([NSNull(), response ?? [], sw1 ?? 0, sw2 ?? 0])
+                }
+            }
+        )
+    }
+
+    @objc(sendCommandAPDU:callback:)
+    static func sendCommandAPDU(
+        _ payload: NSDictionary,
+        callback: @escaping RNNfcResponseSenderBlock
+    ) {
+        forwardWithTagSessionSupport(
+            isTagSessionSupported(),
+            callback: callback,
+            operation: { tagSession in
+                sendCommandAPDU(with: tagSession, payload: payload) { response, sw1, sw2, error in
+                    if let error {
+                        callback([RNNfcSwiftUtil.errorMessage(from: error as NSError), NSNull()])
+                        return
+                    }
+
+                    callback([NSNull(), response ?? [], sw1 ?? 0, sw2 ?? 0])
+                }
+            }
+        )
+    }
+
+    @objc(sendCommandAPDUBytesWithSession:bytes:completion:)
+    static func sendCommandAPDUBytes(
+        with session: NFCTagReaderSession,
+        bytes: [NSNumber],
+        completion: @escaping RNNfcIsoDepResultBlock
+    ) {
+        guard let connectedTag = session.connectedTag else {
+            completion(nil, nil, nil, NSError(domain: "RNNfcTechSwiftService", code: 1, userInfo: [NSLocalizedDescriptionKey: "Not connected"]))
+            return
+        }
+
+        let iso7816Tag = extractIso7816Tag(from: connectedTag)
+        guard let iso7816Tag else {
+            completion(nil, nil, nil, NSError(domain: "RNNfcTechSwiftService", code: 4, userInfo: [NSLocalizedDescriptionKey: "not an iso7816 tag"]))
+            return
+        }
+
+        let data = RNNfcSwiftUtil.data(from: bytes)
+        guard let apdu = NFCISO7816APDU(data: data) else {
+            completion(nil, nil, nil, NSError(domain: "RNNfcTechSwiftService", code: 5, userInfo: [NSLocalizedDescriptionKey: "invalid apdu data"]))
+            return
+        }
+
+        iso7816Tag.sendCommand(apdu: apdu) { response, sw1, sw2, error in
+            if let error {
+                completion(nil, nil, nil, error as NSError)
+                return
+            }
+
+            completion(
+                RNNfcSwiftUtil.numberArray(from: response),
+                NSNumber(value: Int(sw1)),
+                NSNumber(value: Int(sw2)),
+                nil
+            )
+        }
+    }
+
+    @objc(sendCommandAPDUWithSession:payload:completion:)
+    static func sendCommandAPDU(
+        with session: NFCTagReaderSession,
+        payload: NSDictionary,
+        completion: @escaping RNNfcIsoDepResultBlock
+    ) {
+        guard let connectedTag = session.connectedTag else {
+            completion(nil, nil, nil, NSError(domain: "RNNfcTechSwiftService", code: 1, userInfo: [NSLocalizedDescriptionKey: "Not connected"]))
+            return
+        }
+
+        let iso7816Tag = extractIso7816Tag(from: connectedTag)
+        guard let iso7816Tag else {
+            completion(nil, nil, nil, NSError(domain: "RNNfcTechSwiftService", code: 4, userInfo: [NSLocalizedDescriptionKey: "not an iso7816 tag"]))
+            return
+        }
+
+        guard
+            let cla = payload["cla"] as? NSNumber,
+            let ins = payload["ins"] as? NSNumber,
+            let p1 = payload["p1"] as? NSNumber,
+            let p2 = payload["p2"] as? NSNumber,
+            let dataArray = payload["data"] as? [NSNumber],
+            let le = payload["le"] as? NSNumber
+        else {
+            completion(nil, nil, nil, NSError(domain: "RNNfcTechSwiftService", code: 6, userInfo: [NSLocalizedDescriptionKey: "invalid apdu payload"]))
+            return
+        }
+
+        let data = RNNfcSwiftUtil.data(from: dataArray)
+        let apdu = NFCISO7816APDU(
+            instructionClass: cla.uint8Value,
+            instructionCode: ins.uint8Value,
+            p1Parameter: p1.uint8Value,
+            p2Parameter: p2.uint8Value,
+            data: data,
+            expectedResponseLength: le.intValue
+        )
+
+        iso7816Tag.sendCommand(apdu: apdu) { response, sw1, sw2, error in
+            if let error {
+                completion(nil, nil, nil, error as NSError)
+                return
+            }
+
+            completion(
+                RNNfcSwiftUtil.numberArray(from: response),
+                NSNumber(value: Int(sw1)),
+                NSNumber(value: Int(sw2)),
+                nil
+            )
+        }
+    }
+
+    private static func extractIso7816Tag(from connectedTag: NFCTag) -> NFCISO7816Tag? {
+        if case let .iso7816(tag) = connectedTag {
+            return tag
+        }
+        return nil
+    }
+}

package/ios/RNNfcManager+Mifare.swift

@@ -0,0 +1,61 @@
+import CoreNFC
+import Foundation
+
+public extension RNNfcManager {
+    @objc(sendMifareCommand:callback:)
+    static func sendMifareCommand(
+        _ bytes: [NSNumber],
+        callback: @escaping RNNfcResponseSenderBlock
+    ) {
+        forwardWithTagSessionSupport(
+            isTagSessionSupported(),
+            callback: callback,
+            operation: { tagSession in
+                sendMifareCommand(with: tagSession, bytes: bytes) { response, error in
+                    if let error {
+                        callback([RNNfcSwiftUtil.errorMessage(from: error as NSError), NSNull()])
+                        return
+                    }
+
+                    callback([NSNull(), response ?? []])
+                }
+            }
+        )
+    }
+
+    @objc(sendMifareCommandWithSession:bytes:completion:)
+    static func sendMifareCommand(
+        with session: NFCTagReaderSession,
+        bytes: [NSNumber],
+        completion: @escaping RNNfcDataResultBlock
+    ) {
+        guard let connectedTag = session.connectedTag else {
+            completion(nil, NSError(domain: "RNNfcTechSwiftService", code: 1, userInfo: [NSLocalizedDescriptionKey: "Not connected"]))
+            return
+        }
+
+        let mifareTag = extractMifareTag(from: connectedTag)
+        guard let mifareTag else {
+            completion(nil, NSError(domain: "RNNfcTechSwiftService", code: 2, userInfo: [NSLocalizedDescriptionKey: "not a mifare tag"]))
+            return
+        }
+
+        let data = RNNfcSwiftUtil.data(from: bytes)
+        NSLog("input bytes: %@", RNNfcSwiftUtil.hexString(from: data))
+        mifareTag.sendMiFareCommand(commandPacket: data) { response, error in
+            if let error {
+                completion(nil, error as NSError)
+                return
+            }
+
+            completion(RNNfcSwiftUtil.numberArray(from: response), nil)
+        }
+    }
+
+    private static func extractMifareTag(from connectedTag: NFCTag) -> NFCMiFareTag? {
+        if case let .miFare(tag) = connectedTag {
+            return tag
+        }
+        return nil
+    }
+}

package/ios/RNNfcManager+Ndef.swift

@@ -0,0 +1,120 @@
+import CoreNFC
+import Foundation
+
+public extension RNNfcManager {
+    @objc(getNdefMessageFromTagSession:callback:)
+    static func getNdefMessage(
+        from tagSession: NFCTagReaderSession?,
+        callback: @escaping RNNfcResponseSenderBlock
+    ) {
+        guard let ndefTag = requireConnectedNdefTag(from: tagSession) else {
+            callback(["No ndef available", NSNull()])
+            return
+        }
+
+        ndefTag.readNDEF { ndefMessage, error in
+            if let error {
+                callback([RNNfcSwiftUtil.errorMessage(from: error as NSError), NSNull()])
+                return
+            }
+
+            let converted = ndefMessage.map { convertNdefMessage($0) } ?? []
+            callback([NSNull(), ["ndefMessage": converted]])
+        }
+    }
+
+    @objc(writeNdefMessage:toTagSession:callback:)
+    static func writeNdefMessage(
+        _ bytes: [NSNumber],
+        to tagSession: NFCTagReaderSession?,
+        callback: @escaping RNNfcResponseSenderBlock
+    ) {
+        guard let ndefTag = requireConnectedNdefTag(from: tagSession) else {
+            callback(["No ndef available", NSNull()])
+            return
+        }
+
+        let data = RNNfcSwiftUtil.data(from: bytes)
+        guard let ndefMessage = NFCNDEFMessage(data: data) else {
+            callback(["invalid ndef msg"])
+            return
+        }
+
+        ndefTag.writeNDEF(ndefMessage) { error in
+            if let error {
+                callback([RNNfcSwiftUtil.errorMessage(from: error as NSError), NSNull()])
+                return
+            }
+
+            callback([])
+        }
+    }
+
+    @objc(makeTagReadOnlyFromTagSession:callback:)
+    static func makeTagReadOnly(
+        from tagSession: NFCTagReaderSession?,
+        callback: @escaping RNNfcResponseSenderBlock
+    ) {
+        guard let ndefTag = requireConnectedNdefTag(from: tagSession) else {
+            callback(["No ndef available", NSNull()])
+            return
+        }
+
+        ndefTag.writeLock { error in
+            if let error {
+                callback([RNNfcSwiftUtil.errorMessage(from: error as NSError), NSNull()])
+                return
+            }
+
+            callback([])
+        }
+    }
+
+    @objc(queryNdefStatusFromTagSession:callback:)
+    static func queryNdefStatus(
+        from tagSession: NFCTagReaderSession?,
+        callback: @escaping RNNfcResponseSenderBlock
+    ) {
+        guard let ndefTag = requireConnectedNdefTag(from: tagSession) else {
+            callback(["No ndef available", NSNull()])
+            return
+        }
+
+        ndefTag.queryNDEFStatus { status, capacity, error in
+            if let error {
+                callback([RNNfcSwiftUtil.errorMessage(from: error as NSError), NSNull()])
+                return
+            }
+
+            let payload: [String: NSNumber] = [
+                "status": NSNumber(value: Int(status.rawValue)),
+                "capacity": NSNumber(value: Int(capacity)),
+            ]
+            callback([NSNull(), payload])
+        }
+    }
+
+    private static func requireConnectedNdefTag(from tagSession: NFCTagReaderSession?) -> NFCNDEFTag? {
+        guard let connectedTag = tagSession?.connectedTag else {
+            return nil
+        }
+
+        return getNdefTagHandle(from: connectedTag)
+    }
+
+    private static func getNdefTagHandle(from tag: NFCTag) -> NFCNDEFTag? {
+        switch tag {
+        case .miFare(let mifareTag):
+            return mifareTag
+        case .iso7816(let iso7816Tag):
+            return iso7816Tag
+        case .feliCa(let felicaTag):
+            return felicaTag
+        case .iso15693(let iso15693Tag):
+            return iso15693Tag
+        @unknown default:
+            return nil
+        }
+    }
+
+}

package/ios/RNNfcManager.h

@@ -0,0 +1,251 @@
+#import <Foundation/Foundation.h>
+#import <CoreNFC/CoreNFC.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^RNNfcDataResultBlock)(NSArray<NSNumber *> * _Nullable response, NSError * _Nullable error);
+typedef void (^RNNfcIsoDepResultBlock)(NSArray<NSNumber *> * _Nullable response, NSNumber * _Nullable sw1, NSNumber * _Nullable sw2, NSError * _Nullable error);
+typedef void (^RNNfcIso15693SystemInfoResultBlock)(NSDictionary * _Nullable systemInfo, NSError * _Nullable error);
+typedef void (^RNNfcIso15693BlocksResultBlock)(NSArray * _Nullable blocks, NSError * _Nullable error);
+typedef void (^RNNfcVoidResultBlock)(NSError * _Nullable error);
+typedef void (^RNNfcIso15693SendRequestResultBlock)(NSNumber * _Nullable responseFlag, NSArray<NSNumber *> * _Nullable response, NSError * _Nullable error);
+typedef void (^RNNfcResponseSenderBlock)(NSArray * _Nonnull response);
+
+@interface RNNfcManager : NSObject
+
++ (BOOL)isTagSessionSupported;
++ (BOOL)isIso15693Supported;
+
++ (void)isSupported:(NSString *)tech
+           callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)startWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)resetRuntimeState;
++ (void)invalidateRuntimeState;
+
++ (NSObject *)createSessionDelegateProxy;
+
++ (BOOL)ensureNoActiveSessionForCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)createAndBeginTagSessionWithTechs:(NSArray<NSString *> *)techs
+                                  options:(NSDictionary *)options
+                                 callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)createAndBeginNdefSessionWithOptions:(NSDictionary *)options
+                                     callback:(RNNfcResponseSenderBlock)callback;
+
++ (NFCTagReaderSession * _Nullable)requireTagSessionRegisteredWithCallback:(RNNfcResponseSenderBlock)callback
+                                                          noSessionMessage:(NSString *)noSessionMessage;
+
++ (NFCNDEFReaderSession * _Nullable)requireNdefSessionRegisteredWithCallback:(RNNfcResponseSenderBlock)callback
+                                                             noSessionMessage:(NSString *)noSessionMessage;
+
++ (void)invalidateActiveSessionWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)invalidateSessionWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)invalidateActiveSessionWithErrorMessage:(NSString *)errorMessage
+                                       callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)invalidateSessionWithErrorMessage:(NSString *)errorMessage
+                                 callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)restartTechnologyRequestWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)cancelTechnologyRequestWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)unregisterTagEventWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)setAlertMessage:(NSString *)alertMessage
+               callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)isSessionAvailableWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)isTagSessionAvailableWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)sendMifareCommand:(NSArray<NSNumber *> *)bytes
+                                                        callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)sendFelicaCommand:(NSArray<NSNumber *> *)bytes
+                                                       callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)sendCommandAPDUBytes:(NSArray<NSNumber *> *)bytes
+                                                          callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)sendCommandAPDU:(NSDictionary *)payload
+                                          callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)getNdefMessageFromTagSession:(NFCTagReaderSession * _Nullable)tagSession
+                                               callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)writeNdefMessage:(NSArray<NSNumber *> *)bytes
+                           toTagSession:(NFCTagReaderSession * _Nullable)tagSession
+                                callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)makeTagReadOnlyFromTagSession:(NFCTagReaderSession * _Nullable)tagSession
+                                                   callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)queryNdefStatusFromTagSession:(NFCTagReaderSession * _Nullable)tagSession
+                                                   callback:(RNNfcResponseSenderBlock)callback;
+
++ (NSArray *)convertNdefMessage:(NFCNDEFMessage *)message;
+
++ (void)getTagWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)getTagFromTagSession:(NFCTagReaderSession * _Nullable)tagSession
+                      callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)getNdefMessageWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)writeNdefMessage:(NSArray<NSNumber *> *)bytes
+                 options:(NSDictionary *)options
+                callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)makeReadOnlyWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)queryNdefStatusWithCallback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693GetSystemInfo:(NSNumber *)flags
+                                            callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693ReadSingleBlock:(NSDictionary *)options
+                                              callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693ReadMultipleBlocks:(NSDictionary *)options
+                                                  callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693WriteSingleBlock:(NSDictionary *)options
+                                               callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693LockBlock:(NSDictionary *)options
+                                          callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693WriteAFI:(NSDictionary *)options
+                                        callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693LockAFI:(NSDictionary *)options
+                                       callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693WriteDSFID:(NSDictionary *)options
+                                          callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693LockDSFID:(NSDictionary *)options
+                                         callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693ResetToReady:(NSDictionary *)options
+                                            callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693Select:(NSDictionary *)options
+                                       callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693StayQuiet:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693CustomCommand:(NSDictionary *)options
+                                             callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693SendRequest:(NSDictionary *)options
+                                           callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693ExtendedReadSingleBlock:(NSDictionary *)options
+                                                      callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693ExtendedReadMultipleBlocks:(NSDictionary *)options
+                                                           callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693ExtendedWriteSingleBlock:(NSDictionary *)options
+                                                       callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)iso15693ExtendedLockBlock:(NSDictionary *)options
+                                                 callback:(RNNfcResponseSenderBlock)callback;
+
++ (void)sendMifareCommandWithSession:(NFCTagReaderSession *)session
+                               bytes:(NSArray<NSNumber *> *)bytes
+                                          completion:(RNNfcDataResultBlock)completion;
+
++ (void)sendFelicaCommandWithSession:(NFCTagReaderSession *)session
+                               bytes:(NSArray<NSNumber *> *)bytes
+                                          completion:(RNNfcDataResultBlock)completion;
+
++ (void)sendCommandAPDUBytesWithSession:(NFCTagReaderSession *)session
+                                   bytes:(NSArray<NSNumber *> *)bytes
+                                                  completion:(RNNfcIsoDepResultBlock)completion;
+
++ (void)sendCommandAPDUWithSession:(NFCTagReaderSession *)session
+                            payload:(NSDictionary *)payload
+                                         completion:(RNNfcIsoDepResultBlock)completion;
+
++ (void)iso15693GetSystemInfoWithSession:(NFCTagReaderSession *)session
+                                                            flags:(NSNumber *)flags
+                                                   completion:(RNNfcIso15693SystemInfoResultBlock)completion;
+
++ (void)iso15693ReadSingleBlockWithSession:(NFCTagReaderSession *)session
+                                                            options:(NSDictionary *)options
+                                                       completion:(RNNfcDataResultBlock)completion;
+
++ (void)iso15693ReadMultipleBlocksWithSession:(NFCTagReaderSession *)session
+                                                                 options:(NSDictionary *)options
+                                                            completion:(RNNfcIso15693BlocksResultBlock)completion;
+
++ (void)iso15693WriteSingleBlockWithSession:(NFCTagReaderSession *)session
+                                                             options:(NSDictionary *)options
+                                                        completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693LockBlockWithSession:(NFCTagReaderSession *)session
+                                                  options:(NSDictionary *)options
+                                             completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693WriteAFIWithSession:(NFCTagReaderSession *)session
+                                              options:(NSDictionary *)options
+                                         completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693LockAFIWithSession:(NFCTagReaderSession *)session
+                                             options:(NSDictionary *)options
+                                        completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693WriteDSFIDWithSession:(NFCTagReaderSession *)session
+                                                  options:(NSDictionary *)options
+                                             completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693LockDSFIDWithSession:(NFCTagReaderSession *)session
+                                               options:(NSDictionary *)options
+                                          completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693ResetToReadyWithSession:(NFCTagReaderSession *)session
+                                                       options:(NSDictionary *)options
+                                                  completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693SelectWithSession:(NFCTagReaderSession *)session
+                                             options:(NSDictionary *)options
+                                        completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693StayQuietWithSession:(NFCTagReaderSession *)session
+                                              completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693CustomCommandWithSession:(NFCTagReaderSession *)session
+                                                        options:(NSDictionary *)options
+                                                   completion:(RNNfcDataResultBlock)completion;
+
++ (void)iso15693SendRequestWithSession:(NFCTagReaderSession *)session
+                                                    options:(NSDictionary *)options
+                                               completion:(RNNfcIso15693SendRequestResultBlock)completion;
+
++ (void)iso15693ExtendedReadSingleBlockWithSession:(NFCTagReaderSession *)session
+                                                                        options:(NSDictionary *)options
+                                                                   completion:(RNNfcDataResultBlock)completion;
+
++ (void)iso15693ExtendedReadMultipleBlocksWithSession:(NFCTagReaderSession *)session
+                                                                             options:(NSDictionary *)options
+                                                                        completion:(RNNfcIso15693BlocksResultBlock)completion;
+
++ (void)iso15693ExtendedWriteSingleBlockWithSession:(NFCTagReaderSession *)session
+                                                                           options:(NSDictionary *)options
+                                                                      completion:(RNNfcVoidResultBlock)completion;
+
++ (void)iso15693ExtendedLockBlockWithSession:(NFCTagReaderSession *)session
+                                                              options:(NSDictionary *)options
+                                                         completion:(RNNfcVoidResultBlock)completion;
+
+@end
+
+NS_ASSUME_NONNULL_END