@exxili/capacitor-nfc 0.0.12 → 0.0.13

package/ios/Sources/NFCPlugin/NFCReader.swift

@@ -1,41 +1,305 @@
 import Foundation
 import CoreNFC
+// swiftlint:disable:next type_body_length
+@objc public class NFCReader: NSObject, NFCTagReaderSessionDelegate, NFCNDEFReaderSessionDelegate {
+    public func tagReaderSessionDidBecomeActive(_ session: NFCTagReaderSession) {
+        // Intentionally left blank; no special handling needed when tag session becomes active.
+    }
+    private enum ReaderMode {
+        case fullTag
+        case limitedTag
+        case ndefFallback
+
+        var alertSuffix: String {
+            switch self {
+            case .fullTag:
+                return "."
+            case .limitedTag:
+                return " (compatibility mode)."
+            case .ndefFallback:
+                return " (NDEF mode)."
+            }
+        }
+
+        var metadataValue: String {
+            switch self {
+            case .fullTag:
+                return "full"
+            case .limitedTag:
+                return "compat"
+            case .ndefFallback:
+                return "ndef"
+            }
+        }
+    }
 
-@objc public class NFCReader: NSObject, NFCTagReaderSessionDelegate {
     private var readerSession: NFCTagReaderSession?
+    private var ndefReaderSession: NFCNDEFReaderSession?
+    private var readerMode: ReaderMode = .fullTag
+    private var autoRestartWorkItem: DispatchWorkItem?
+    private var entitlementFailureDetected = false
+    private var lastFallbackSignature: (mode: ReaderMode, reason: String?)?
 
     public var onNDEFMessageReceived: (([NFCNDEFMessage], [String: Any]?) -> Void)?
     public var onError: ((Error) -> Void)?
 
+    @objc public func setPreferredReaderMode(_ rawMode: String?) {
+        guard let rawMode = rawMode?.lowercased() else { return }
+        switch rawMode {
+        case "full", "advanced", "forcefull":
+            readerMode = .fullTag
+            entitlementFailureDetected = false
+            lastFallbackSignature = nil
+        case "compat", "compatibility", "limited":
+            readerMode = .limitedTag
+            lastFallbackSignature = nil
+        case "ndef":
+            readerMode = .ndefFallback
+            lastFallbackSignature = nil
+        case "auto":
+            if entitlementFailureDetected {
+                if readerMode == .fullTag {
+                    readerMode = .limitedTag
+                }
+            } else {
+                readerMode = .fullTag
+                lastFallbackSignature = nil
+            }
+        default:
+            break
+        }
+        if readerMode == .fullTag {
+            lastFallbackSignature = nil
+        }
+    }
+
     @objc public func startScanning() {
         print("NFCReader startScanning called")
-
         guard NFCNDEFReaderSession.readingAvailable else {
             print("NFC scanning not supported on this device")
             return
         }
-        readerSession = NFCTagReaderSession(pollingOption: [.iso14443, .iso15693, .iso18092], delegate: self, queue: nil)
-        readerSession?.alertMessage = "Hold your iPhone near the NFC tag."
-        readerSession?.begin()
+        if readerMode != .fullTag {
+            let reason = entitlementFailureDetected ? "missing-entitlement" : nil
+            emitFallbackMetadata(for: readerMode, reason: reason)
+        }
+
+        autoRestartWorkItem?.cancel()
+        startCurrentModeSession()
     }
 
     @objc public func cancelScanning() {
-        if let session = readerSession {
-            session.invalidate()
-        }
+        autoRestartWorkItem?.cancel()
+        autoRestartWorkItem = nil
+        if let session = readerSession { session.invalidate() }
+        if let ndef = ndefReaderSession { ndef.invalidate() }
         readerSession = nil
-    }
-
-    // NFCTagReaderSessionDelegate methods
-    public func tagReaderSessionDidBecomeActive(_ session: NFCTagReaderSession) {
-        
+        ndefReaderSession = nil
+        lastFallbackSignature = nil
     }
 
     public func tagReaderSession(_ session: NFCTagReaderSession, didInvalidateWithError error: Error) {
         print("NFC reader session error: \(error.localizedDescription)")
+        lastFallbackSignature = nil
+        readerSession = nil
+        guard let nfcError = error as? NFCReaderError else {
+            onError?(error)
+            return
+        }
+
+        if handleEntitlementOrSystemErrors(nfcError) {
+            return
+        }
+
+        if nfcError.code == .readerSessionInvalidationErrorUserCanceled {
+            return
+        }
+
         onError?(error)
     }
 
+    private func startCurrentModeSession() {
+        switch readerMode {
+        case .fullTag:
+            beginTagSession(pollingOption: [.iso14443, .iso15693, .iso18092])
+        case .limitedTag:
+            beginTagSession(pollingOption: [.iso14443])
+        case .ndefFallback:
+            beginNDEFFallbackSession()
+        }
+    }
+
+    private func beginTagSession(pollingOption: NFCTagReaderSession.PollingOption) {
+        guard NFCTagReaderSession.readingAvailable else {
+            print("[NFC] Tag reading not supported on this device")
+            return
+        }
+        DispatchQueue.main.async {
+            if let existingSession = self.readerSession {
+                existingSession.invalidate()
+            }
+            self.ndefReaderSession?.invalidate()
+            self.ndefReaderSession = nil
+
+            guard let session = NFCTagReaderSession(pollingOption: pollingOption, delegate: self, queue: nil) else {
+                print("[NFC] Failed to create NFCTagReaderSession (nil).")
+                return
+            }
+            session.alertMessage = "Hold your iPhone near the NFC tag" + self.readerMode.alertSuffix
+            self.readerSession = session
+            session.begin()
+        }
+    }
+
+    private func beginNDEFFallbackSession() {
+        guard NFCNDEFReaderSession.readingAvailable else { return }
+        DispatchQueue.main.async {
+            if self.ndefReaderSession != nil { return }
+            let session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false)
+            session.alertMessage = "Hold your iPhone near the NFC tag. (NDEF mode)"
+            self.ndefReaderSession = session
+            session.begin()
+        }
+    }
+
+    private func scheduleRestart(after delay: TimeInterval = 0.25) {
+        autoRestartWorkItem?.cancel()
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self = self else { return }
+            self.autoRestartWorkItem = nil
+            self.startCurrentModeSession()
+        }
+        autoRestartWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: workItem)
+    }
+
+    private func emitFallbackMetadata(for mode: ReaderMode, reason: String? = nil) {
+        guard mode != .fullTag else { return }
+        if let last = lastFallbackSignature, last.mode == mode, last.reason == reason {
+            return
+        }
+        lastFallbackSignature = (mode, reason)
+
+        var metadata: [String: Any] = [
+            "fallback": true,
+            "fallbackMode": mode.metadataValue
+        ]
+        if let reason = reason {
+            metadata["reason"] = reason
+        }
+        DispatchQueue.main.async {
+            self.onNDEFMessageReceived?([], metadata)
+        }
+    }
+
+    private func handleEntitlementOrSystemErrors(_ error: NFCReaderError) -> Bool {
+        let description = error.localizedDescription.lowercased()
+
+        if description.contains("missing required entitlement") || error.code == .readerErrorSecurityViolation {
+            if readerMode == .fullTag {
+                print("[NFC] Missing advanced tag entitlement detected -> switching to compatibility mode")
+                readerMode = .limitedTag
+                entitlementFailureDetected = true
+                emitFallbackMetadata(for: readerMode, reason: "missing-entitlement")
+                scheduleRestart()
+                return true
+            }
+
+            if readerMode == .limitedTag {
+                print("[NFC] Compatibility mode also unavailable -> falling back to NDEF session")
+                readerMode = .ndefFallback
+                entitlementFailureDetected = true
+                emitFallbackMetadata(for: readerMode, reason: "missing-entitlement")
+                scheduleRestart()
+                return true
+            }
+        }
+
+        if description.contains("system resource unavailable") || error.code == .readerSessionInvalidationErrorSystemIsBusy {
+            print("[NFC] System resource unavailable; retrying current reader mode")
+            scheduleRestart(after: 0.35)
+            return true
+        }
+
+        return false
+    }
+
+    // MARK: - NFCNDEFReaderSessionDelegate
+    public func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
+        print("NDEF reader session error: \(error.localizedDescription)")
+        if session === ndefReaderSession {
+            ndefReaderSession = nil
+            lastFallbackSignature = nil
+        }
+        onError?(error)
+    }
+
+    // Called when the NFCNDEFReaderSession becomes active (needed to silence runtime delegate warning)
+    public func readerSessionDidBecomeActive(_ session: NFCNDEFReaderSession) {
+        let isFallback = (session === ndefReaderSession)
+        print("NDEF reader session became active (fallback mode: \(isFallback))")
+        if isFallback {
+            let reason = entitlementFailureDetected ? "missing-entitlement" : nil
+            emitFallbackMetadata(for: .ndefFallback, reason: reason)
+        }
+    }
+
+    public func readerSession(_ session: NFCNDEFReaderSession, didDetect tags: [NFCNDEFTag]) {
+        // Mirror writer logic for reading first NDEF tag
+        if tags.count > 1 {
+            let retryInterval = DispatchTimeInterval.milliseconds(500)
+            session.alertMessage = "More than one tag detected. Please try again."
+            DispatchQueue.global().asyncAfter(deadline: .now() + retryInterval) {
+                session.restartPolling()
+            }
+            return
+        }
+        guard let tag = tags.first else { return }
+        session.connect(to: tag) { connectError in
+            if let connectError = connectError {
+                session.invalidate(errorMessage: "Unable to connect to tag.")
+                self.onError?(connectError)
+                return
+            }
+            tag.queryNDEFStatus { status, _, statusError in
+                if let statusError = statusError {
+                    session.invalidate(errorMessage: "Unable to query the NDEF status of tag.")
+                    self.onError?(statusError)
+                    return
+                }
+                guard status != .notSupported else {
+                    session.invalidate(errorMessage: "Tag is not NDEF compliant.")
+                    return
+                }
+                tag.readNDEF { message, readError in
+                    if let readError = readError {
+                        session.invalidate(errorMessage: "Failed to read NDEF message.")
+                        self.onError?(readError)
+                        return
+                    }
+                    if let message = message {
+                        session.alertMessage = "Found 1 NDEF message."
+                        session.invalidate()
+                        self.onNDEFMessageReceived?([message], nil)
+                    } else {
+                        session.alertMessage = "No NDEF message found."
+                        session.invalidate()
+                        self.onNDEFMessageReceived?([], nil)
+                    }
+                }
+            }
+        }
+    }
+
+    // Some SDK versions (and build settings) still require this legacy delegate method.
+    public func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
+        // Forward directly; no tag info available in this callback.
+        if !messages.isEmpty {
+            session.invalidate()
+            onNDEFMessageReceived?(messages, nil)
+        }
+    }
+
     public func tagReaderSession(_ session: NFCTagReaderSession, didDetect tags: [NFCTag]) {
         if tags.count > 1 {
             let retryInterval = DispatchTimeInterval.milliseconds(500)
@@ -45,18 +309,21 @@ import CoreNFC
             }
             return
         }
-        
-        let tag = tags.first!
+
+        guard let tag = tags.first else {
+            session.invalidate(errorMessage: "No tag found.")
+            return
+        }
         session.connect(to: tag) { (error: Error?) in
             if let error = error {
                 session.invalidate(errorMessage: "Unable to connect to tag.")
                 self.onError?(error)
                 return
             }
-            
+
             // Extract tag information
             let tagInfo = self.extractTagInfo(from: tag)
-            
+
             // Try to read NDEF if the tag supports it
             if case let .iso7816(iso7816Tag) = tag {
                 self.handleISO7816Tag(iso7816Tag, session: session, tagInfo: tagInfo)
@@ -74,44 +341,44 @@ import CoreNFC
             }
         }
     }
-    
+
     private func extractTagInfo(from tag: NFCTag) -> [String: Any] {
         var tagInfo: [String: Any] = [:]
         var techTypes: [String] = []
         var uid: String = ""
-        
+
         switch tag {
         case .iso7816(let iso7816Tag):
             uid = iso7816Tag.identifier.map { String(format: "%02X", $0) }.joined()
             techTypes.append("ISO7816")
             tagInfo["type"] = "ISO7816"
-            
+
         case .miFare(let miFareTag):
             uid = miFareTag.identifier.map { String(format: "%02X", $0) }.joined()
             techTypes.append("MiFare")
             tagInfo["type"] = "MiFare"
-            
+
         case .feliCa(let feliCaTag):
             uid = feliCaTag.currentIDm.map { String(format: "%02X", $0) }.joined()
             techTypes.append("FeliCa")
             tagInfo["type"] = "FeliCa"
-            
+
         case .iso15693(let iso15693Tag):
             uid = iso15693Tag.identifier.map { String(format: "%02X", $0) }.joined()
             techTypes.append("ISO15693")
             tagInfo["type"] = "ISO15693"
-            
+
         @unknown default:
             techTypes.append("Unknown")
             tagInfo["type"] = "Unknown"
         }
-        
+
         tagInfo["uid"] = uid
         tagInfo["techTypes"] = techTypes
-        
+
         return tagInfo
     }
-    
+
     private func handleMiFareTag(_ miFareTag: NFCMiFareTag, session: NFCTagReaderSession, tagInfo: [String: Any]) {
         miFareTag.queryNDEFStatus { (ndefStatus: NFCNDEFStatus, capacity: Int, error: Error?) in
             if let error = error {
@@ -119,25 +386,25 @@ import CoreNFC
                 self.onError?(error)
                 return
             }
-            
+
             if ndefStatus == .notSupported {
                 session.alertMessage = "Tag detected but no NDEF message found."
                 session.invalidate()
                 self.onNDEFMessageReceived?([], tagInfo)
                 return
             }
-            
+
             var updatedTagInfo = tagInfo
             updatedTagInfo["maxSize"] = capacity
             updatedTagInfo["isWritable"] = ndefStatus == .readWrite
-            
+
             miFareTag.readNDEF { (message: NFCNDEFMessage?, error: Error?) in
                 if let error = error {
                     session.invalidate(errorMessage: "Failed to read NDEF from tag.")
                     self.onError?(error)
                     return
                 }
-                
+
                 if let message = message {
                     session.alertMessage = "Found 1 NDEF message."
                     session.invalidate()
@@ -150,14 +417,14 @@ import CoreNFC
             }
         }
     }
-    
+
     private func handleISO7816Tag(_ iso7816Tag: NFCISO7816Tag, session: NFCTagReaderSession, tagInfo: [String: Any]) {
         // ISO7816 tags don't typically support NDEF directly
         session.alertMessage = "Tag detected but no NDEF message found."
         session.invalidate()
         self.onNDEFMessageReceived?([], tagInfo)
     }
-    
+
     private func handleFeliCaTag(_ feliCaTag: NFCFeliCaTag, session: NFCTagReaderSession, tagInfo: [String: Any]) {
         feliCaTag.queryNDEFStatus { (ndefStatus: NFCNDEFStatus, capacity: Int, error: Error?) in
             if let error = error {
@@ -165,25 +432,25 @@ import CoreNFC
                 self.onError?(error)
                 return
             }
-            
+
             if ndefStatus == .notSupported {
                 session.alertMessage = "Tag detected but no NDEF message found."
                 session.invalidate()
                 self.onNDEFMessageReceived?([], tagInfo)
                 return
             }
-            
+
             var updatedTagInfo = tagInfo
             updatedTagInfo["maxSize"] = capacity
             updatedTagInfo["isWritable"] = ndefStatus == .readWrite
-            
+
             feliCaTag.readNDEF { (message: NFCNDEFMessage?, error: Error?) in
                 if let error = error {
                     session.invalidate(errorMessage: "Failed to read NDEF from tag.")
                     self.onError?(error)
                     return
                 }
-                
+
                 if let message = message {
                     session.alertMessage = "Found 1 NDEF message."
                     session.invalidate()
@@ -196,7 +463,7 @@ import CoreNFC
             }
         }
     }
-    
+
     private func handleISO15693Tag(_ iso15693Tag: NFCISO15693Tag, session: NFCTagReaderSession, tagInfo: [String: Any]) {
         iso15693Tag.queryNDEFStatus { (ndefStatus: NFCNDEFStatus, capacity: Int, error: Error?) in
             if let error = error {
@@ -204,25 +471,25 @@ import CoreNFC
                 self.onError?(error)
                 return
             }
-            
+
             if ndefStatus == .notSupported {
                 session.alertMessage = "Tag detected but no NDEF message found."
                 session.invalidate()
                 self.onNDEFMessageReceived?([], tagInfo)
                 return
             }
-            
+
             var updatedTagInfo = tagInfo
             updatedTagInfo["maxSize"] = capacity
             updatedTagInfo["isWritable"] = ndefStatus == .readWrite
-            
+
             iso15693Tag.readNDEF { (message: NFCNDEFMessage?, error: Error?) in
                 if let error = error {
                     session.invalidate(errorMessage: "Failed to read NDEF from tag.")
                     self.onError?(error)
                     return
                 }
-                
+
                 if let message = message {
                     session.alertMessage = "Found 1 NDEF message."
                     session.invalidate()
@@ -236,3 +503,5 @@ import CoreNFC
         }
     }
 }
+
+// Removed supplemental stubs (logNFCFormatsIfAvailable, tagReaderSessionDidBecomeActive) as they are no longer needed.

package/ios/Sources/NFCPlugin/NFCWriter.swift

@@ -31,7 +31,7 @@ import CoreNFC
     }
 
     public func readerSessionDidBecomeActive(_ session: NFCNDEFReaderSession) {
-        
+
     }
 
     public func readerSession(_ session: NFCNDEFReaderSession, didDetect tags: [NFCNDEFTag]) {
@@ -53,7 +53,7 @@ import CoreNFC
                 return
             }
 
-            tag.queryNDEFStatus { (ndefStatus, capacity, error) in
+            tag.queryNDEFStatus { (ndefStatus, _, error) in
                 if let error = error {
                     session.invalidate(errorMessage: "Unable to query the NDEF status of tag.")
                     self.onError?(error)

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "@exxili/capacitor-nfc",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "A Capacitor plugin for reading and writing NFC NDEFtags.",
+  "type": "module",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/plugin.cjs.js",
+      "types": "./dist/esm/index.d.ts"
+    }
+  },
   "types": "dist/esm/index.d.ts",
   "unpkg": "dist/plugin.js",
   "files": [
@@ -38,7 +46,7 @@
     "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
     "eslint": "eslint . --ext ts",
     "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
-    "swiftlint": "node-swiftlint",
+    "swiftlint": "node-swiftlint lint ios/Sources/NFCPlugin --config .swiftlint.yml",
     "docgen": "docgen --api NFCPlugin --output-readme README.md --output-json dist/docs.json",
     "build": "npm run clean && tsc && rollup -c rollup.config.js && rimraf *.tgz && npm pack",
     "clean": "rimraf ./dist",