📱 Core NFC

⭐ Difficulty: ⭐⭐⭐ ⏱️ Est. Time: 2h 📂 System & Network

NFC tag read/write and NDEF message processing framework

iOS 11+NDEF 읽기/쓰기

✨ Core NFC?

Core NFC is a framework that uses the iPhone's NFC chip to read and write NFC tags. It reads NDEF (NFC Data Exchange Format) messages to process URLs, text, contact info, or write new data to tags. It's used for all NFC use cases except Apple Pay and is supported on iPhone 7 and later.

💡 Key Features: NDEF Tag Reading · Tag Writing (iOS 13+) · URL/Text Parsing · Multi-Record Support · Background Tag Reading · ISO 7816/ISO 15693 Support

📖 1. NDEF 태그 읽기

Use NFCNDEFReaderSession to scan NFC tags and read NDEF messages.

NFCReaderManager.swift — NFC Tag Reading

import CoreNFC
import SwiftUI

@Observable
class NFCReaderManager: NSObject {
    var session: NFCNDEFReaderSession?
    var detectedMessages: [NFCNDEFMessage] = []
    var isScanning = false
    var lastError: String?

    // NFC 지원 여부 확인
    var isNFCAvailable: Bool {
        NFCNDEFReaderSession.readingAvailable
    }

    // 태그 읽기 시작
    func startScanning() {
        guard isNFCAvailable else {
            lastError = "이 기기는 NFC를 지원하지 않습니다"
            print("❌ NFC 미지원")
            return
        }

        detectedMessages.removeAll()
        lastError = nil

        // NDEF Reader Session 생성
        session = NFCNDEFReaderSession(
            delegate: self,
            queue: nil,
            invalidateAfterFirstRead: false
        )

        // 사용자에게 표시될 메시지
        session?.alertMessage = "NFC 태그를 iPhone 상단에 가까이 대주세요"

        // 스캔 시작
        session?.begin()
        isScanning = true

        print("🔍 NFC 스캔 시작")
    }

    // 스캔 중지
    func stopScanning() {
        session?.invalidate()
        isScanning = false
        print("⏹️ NFC 스캔 중지")
    }

    // NDEF 레코드 파싱
    func parseNDEFRecords(from message: NFCNDEFMessage) -> [String] {
        var results: [String] = []

        for record in message.records {
            // Type Name Format
            let tnf = record.typeNameFormat

            switch tnf {
            case .nfcWellKnown:
                // URI 레코드
                if let url = record.wellKnownTypeURIPayload() {
                    results.append("🔗 URL: \(url.absoluteString)")
                }
                // Text 레코드
                else if let text = String(data: record.payload, encoding: .utf8) {
                    results.append("📝 Text: \(text)")
                }

            case .absoluteURI:
                if let text = String(data: record.payload, encoding: .utf8) {
                    results.append("🌐 URI: \(text)")
                }

            case .media:
                let mimeType = String(data: record.type, encoding: .utf8) ?? "unknown"
                results.append("📄 Media Type: \(mimeType)")

            case .empty:
                results.append("⚪️ Empty record")

            @unknown default:
                results.append("❓ Unknown record type")
            }

            // Payload 크기
            results.append("  Size: \(record.payload.count) bytes")
        }

        return results
    }
}

📡 2. NDEF Reader 델리게이트

태그 발견 및 메시지 읽기 handling.

NFCReaderManager+Delegate.swift — Reader Delegate

import CoreNFC

extension NFCReaderManager: NFCNDEFReaderSessionDelegate {
    // 태그 발견
    func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
        print("📱 태그 발견! 메시지 개수: \(messages.count)")

        // 메시지 저장
        detectedMessages.append(contentsOf: messages)

        // 각 메시지 처리
        for (index, message) in messages.enumerated() {
            print("  메시지 \(index + 1): \(message.records.count)개 레코드")

            for (recordIndex, record) in message.records.enumerated() {
                print("    레코드 \(recordIndex + 1):")

                // URL 파싱
                if let url = record.wellKnownTypeURIPayload() {
                    print("      🔗 URL: \(url.absoluteString)")
                }

                // Text 파싱
                if let text = parseTextPayload(record.payload) {
                    print("      📝 Text: \(text)")
                }
            }
        }

        // 성공 메시지
        session.alertMessage = "✅ \(messages.count)개 메시지를 읽었습니다"
    }

    // 태그 발견 (고급 API)
    func readerSession(_ session: NFCNDEFReaderSession, didDetect tags: [NFCNDEFTag]) {
        guard tags.count == 1 else {
            session.alertMessage = "⚠️ 태그가 너무 많습니다. 하나만 가까이 대주세요"
            session.restartPolling()
            return
        }

        let tag = tags.first!

        // 태그 연결
        session.connect(to: tag) { error in
            if let error = error {
                session.invalidate(errorMessage: "❌ 태그 연결 실패: \(error.localizedDescription)")
                return
            }

            print("✅ 태그 연결 성공")

            // NDEF 메시지 읽기
            tag.queryNDEFStatus { status, capacity, error in
                if let error = error {
                    session.invalidate(errorMessage: "❌ 상태 확인 실패: \(error.localizedDescription)")
                    return
                }

                print("📊 태그 상태: \(status.rawValue), 용량: \(capacity) bytes")

                switch status {
                case .notSupported:
                    session.invalidate(errorMessage: "❌ NDEF를 지원하지 않는 태그입니다")

                case .readOnly:
                    self.readNDEFMessage(from: tag, session: session)

                case .readWrite:
                    self.readNDEFMessage(from: tag, session: session)

                @unknown default:
                    session.invalidate(errorMessage: "❓ 알 수 없는 태그 상태")
                }
            }
        }
    }

    // NDEF 메시지 읽기
    private func readNDEFMessage(from tag: NFCNDEFTag, session: NFCNDEFReaderSession) {
        tag.readNDEF { message, error in
            if let error = error {
                session.invalidate(errorMessage: "❌ 읽기 실패: \(error.localizedDescription)")
                return
            }

            if let message = message {
                self.detectedMessages.append(message)
                session.alertMessage = "✅ \(message.records.count)개 레코드를 읽었습니다"
                print("📖 NDEF 메시지 읽기 성공")
            }

            session.invalidate()
        }
    }

    // 세션 무효화
    func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
        isScanning = false

        if let nfcError = error as? NFCReaderError {
            switch nfcError.code {
            case .readerSessionInvalidationErrorUserCanceled:
                print("⏹️ 사용자가 스캔을 취소했습니다")
            case .readerSessionInvalidationErrorSessionTimeout:
                print("⏱️ 세션 시간 초과")
                lastError = "스캔 시간이 초과되었습니다"
            case .readerSessionInvalidationErrorFirstNDEFTagRead:
                print("✅ 첫 번째 태그 읽기 완료")
            default:
                print("❌ NFC 에러: \(nfcError.localizedDescription)")
                lastError = nfcError.localizedDescription
            }
        } else {
            print("❌ 에러: \(error.localizedDescription)")
            lastError = error.localizedDescription
        }
    }

    // Text Payload 파싱
    private func parseTextPayload(_ payload: Data) -> String? {
        guard payload.count > 1 else { return nil }

        // Status byte: bit 7 = UTF-16 여부, bit 0-5 = 언어 코드 길이
        let statusByte = payload[0]
        let isUTF16 = (statusByte & 0x80) != 0
        let langCodeLength = Int(statusByte & 0x3F)

        guard payload.count > langCodeLength + 1 else { return nil }

        // 텍스트 추출
        let textData = payload.subdata(in: (1 + langCodeLength)..<payload.count)
        let encoding: String.Encoding = isUTF16 ? .utf16 : .utf8

        return String(data: textData, encoding: encoding)
    }
}

✍️ 3. NFC 태그 쓰기

NDEF 메시지를 태그에 씁니다 (iOS 13+).

NFCWriterManager.swift — NFC Tag Writing

import CoreNFC

@Observable
class NFCWriterManager: NSObject {
    var session: NFCNDEFReaderSession?
    var messageToWrite: NFCNDEFMessage?
    var writeSuccess = false

    // URL을 태그에 쓰기
    func writeURL(_ url: URL) {
        guard NFCNDEFReaderSession.readingAvailable else {
            print("❌ NFC 미지원")
            return
        }

        // NDEF Payload 생성
        guard let payload = NFCNDEFPayload.wellKnownTypeURIPayload(url: url) else {
            print("❌ Payload 생성 실패")
            return
        }

        messageToWrite = NFCNDEFMessage(records: [payload])

        // 세션 시작
        session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false)
        session?.alertMessage = "쓰기를 원하는 NFC 태그를 가까이 대주세요"
        session?.begin()

        print("✍️ URL 쓰기 시작: \(url.absoluteString)")
    }

    // 텍스트를 태그에 쓰기
    func writeText(_ text: String) {
        guard NFCNDEFReaderSession.readingAvailable else { return }

        // Text Payload 생성
        guard let payload = createTextPayload(text: text, languageCode: "en") else {
            print("❌ Text Payload 생성 실패")
            return
        }

        messageToWrite = NFCNDEFMessage(records: [payload])

        session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false)
        session?.alertMessage = "쓰기를 원하는 NFC 태그를 가까이 대주세요"
        session?.begin()

        print("✍️ 텍스트 쓰기 시작: \(text)")
    }

    // 여러 레코드를 태그에 쓰기
    func writeMultipleRecords(url: URL, text: String) {
        guard NFCNDEFReaderSession.readingAvailable else { return }

        var records: [NFCNDEFPayload] = []

        // URL Payload
        if let urlPayload = NFCNDEFPayload.wellKnownTypeURIPayload(url: url) {
            records.append(urlPayload)
        }

        // Text Payload
        if let textPayload = createTextPayload(text: text, languageCode: "en") {
            records.append(textPayload)
        }

        messageToWrite = NFCNDEFMessage(records: records)

        session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: false)
        session?.alertMessage = "쓰기를 원하는 NFC 태그를 가까이 대주세요"
        session?.begin()

        print("✍️ 다중 레코드 쓰기 시작")
    }

    // Text Payload 생성
    private func createTextPayload(text: String, languageCode: String) -> NFCNDEFPayload? {
        guard let textData = text.data(using: .utf8) else { return nil }
        guard let langData = languageCode.data(using: .utf8) else { return nil }

        // Status byte: UTF-8, 언어 코드 길이
        var payload = Data()
        payload.append(UInt8(langData.count))
        payload.append(langData)
        payload.append(textData)

        return NFCNDEFPayload(
            format: .nfcWellKnown,
            type: "T".data(using: .utf8)!,
            identifier: Data(),
            payload: payload
        )
    }
}

extension NFCWriterManager: NFCNDEFReaderSessionDelegate {
    // 태그 발견 (쓰기용)
    func readerSession(_ session: NFCNDEFReaderSession, didDetect tags: [NFCNDEFTag]) {
        guard tags.count == 1, let tag = tags.first else {
            session.alertMessage = "⚠️ 태그가 너무 많습니다"
            session.restartPolling()
            return
        }

        session.connect(to: tag) { error in
            if let error = error {
                session.invalidate(errorMessage: "❌ 연결 실패: \(error.localizedDescription)")
                return
            }

            // 태그 상태 확인
            tag.queryNDEFStatus { status, capacity, error in
                if let error = error {
                    session.invalidate(errorMessage: "❌ 상태 확인 실패: \(error.localizedDescription)")
                    return
                }

                guard status == .readWrite else {
                    session.invalidate(errorMessage: "❌ 읽기 전용 태그입니다")
                    return
                }

                // 메시지 쓰기
                guard let message = self.messageToWrite else {
                    session.invalidate(errorMessage: "❌ 쓸 메시지가 없습니다")
                    return
                }

                tag.writeNDEF(message) { error in
                    if let error = error {
                        session.invalidate(errorMessage: "❌ 쓰기 실패: \(error.localizedDescription)")
                    } else {
                        session.alertMessage = "✅ 쓰기 성공!"
                        self.writeSuccess = true
                        print("✅ NFC 태그 쓰기 완료")
                        session.invalidate()
                    }
                }
            }
        }
    }

    func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
        // 쓰기 모드에서는 사용하지 않음
    }

    func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
        if let nfcError = error as? NFCReaderError,
           nfcError.code != .readerSessionInvalidationErrorUserCanceled {
            print("❌ 세션 종료: \(error.localizedDescription)")
        }
    }
}

📱 4. SwiftUI Integration

NFC 리더/라이터 UI implementation.

NFCReaderView.swift — NFC UI

import SwiftUI

struct NFCReaderView: View {
    @State private var readerManager = NFCReaderManager()
    @State private var writerManager = NFCWriterManager()
    @State private var urlText = "https://developer.apple.com"
    @State private var writeText = "Hello NFC!"

    var body: some View {
        NavigationStack {
            Form {
                // 읽기 섹션
                Section("태그 읽기") {
                    Button {
                        readerManager.startScanning()
                    } label: {
                        Label("NFC 태그 스캔", systemImage: "wave.3.right")
                    }
                    .disabled(!readerManager.isNFCAvailable || readerManager.isScanning)

                    if readerManager.isScanning {
                        HStack {
                            ProgressView()
                            Text("스캔 중...")
                                .foregroundStyle(.secondary)
                        }
                    }
                }

                // 읽은 메시지
                if !readerManager.detectedMessages.isEmpty {
                    Section("스캔 결과") {
                        ForEach(readerManager.detectedMessages.indices, id: \.self) { index in
                            let message = readerManager.detectedMessages[index]
                            VStack(alignment: .leading, spacing: 8) {
                                Text("메시지 \(index + 1)")
                                    .font(.headline)

                                ForEach(readerManager.parseNDEFRecords(from: message), id: \.self) { record in
                                    Text(record)
                                        .font(.caption)
                                        .foregroundStyle(.secondary)
                                }
                            }
                        }
                    }
                }

                // 쓰기 섹션
                Section("태그 쓰기") {
                    TextField("URL", text: $urlText)
                        .keyboardType(.URL)
                        .autocapitalization(.none)

                    Button {
                        if let url = URL(string: urlText) {
                            writerManager.writeURL(url)
                        }
                    } label: {
                        Label("URL 쓰기", systemImage: "link")
                    }
                    .disabled(!readerManager.isNFCAvailable)

                    TextField("텍스트", text: $writeText)

                    Button {
                        writerManager.writeText(writeText)
                    } label: {
                        Label("텍스트 쓰기", systemImage: "text.cursor")
                    }
                    .disabled(!readerManager.isNFCAvailable)
                }

                // 상태
                Section {
                    Text("NFC 지원: \(readerManager.isNFCAvailable ? "✅" : "❌")")
                        .foregroundStyle(.secondary)

                    if let error = readerManager.lastError {
                        Text("에러: \(error)")
                            .foregroundStyle(.red)
                            .font(.caption)
                    }
                }
            }
            .navigationTitle("NFC 리더/라이터")
        }
    }
}

💡 HIG Guidelines

Permission Settings: Must add NFCReaderUsageDescription to Info.plist
Entitlements: Enable Near Field Communication Tag Reading capability
사용자 안내: alertMessage로 명확한 지시사항 제공
타임아웃: 60초 스캔 제한 시간 고려
백그라운드 읽기: Specific NDEF tags can be read even when the app is in the background

🎯 Practical Usage

스마트 포스터: URL, 연락처 정보가 담긴 포스터
제품 인증: NFC 태그로 정품 인증
출입 관리: NFC 태그 기반 출입증
자산 추적: 장비/재고 관리
박물관 가이드: 전시물 정보 제공

📚 Learn More

⚡️ Performance Tips: NFC 스캔은 60초 후 자동 종료. invalidateAfterFirstRead to false to read multiple tags consecutively. Always check tag capacity and status before writing.

📎 Apple Official Resources

📘 Documentation 💻 Sample Code 🎬 WWDC Sessions