Utilizando el Marco Nfc Ios Core para el intercambio de datos sin contacto

Ciclo de vida básico de la sesión de NFC

El objeto central para leer las etiquetas NDEF es . Una sesión comienza cuando usted llama y termina automáticamente cuando una etiqueta se lee (si es verdad) o cuando usted lo invalida manualmente. Durante la sesión, el sistema muestra una alerta UI proporcionada por el sistema que le dice al usuario que mantenga el dispositivo cerca de una etiqueta.

Iniciar una sesión

import CoreNFC

class NFCHandler: NSObject, NFCNDEFReaderSessionDelegate {
 private var session: NFCNDEFReaderSession?

 func beginScanning() {
 guard NFCNDEFReaderSession.readingAvailable else {
 print("NFC is not available on this device.")
 return
 }
 session = NFCNDEFReaderSession(delegate: self, queue: DispatchQueue.main, invalidateAfterFirstRead: true)
 session?.alertMessage = "Hold your iPhone near the tag."
 session?.begin()
 }
}

Manejo de los callbacks delegados

Aplicar los dos métodos de delegación necesarios:

• – Llamado cuando uno o más mensajes de ECM se leen con éxito. El método recibe una variedad de objetos , cada uno que contiene registros.
• – Llamado cuando la sesión termina, ya sea porque se leía una etiqueta o se cometió un error (por ejemplo, usuario cancelado, etiqueta sin soporte). Utilice este método para restablecer el estado e informar al usuario.

Ejemplo de aplicación:

func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
 for message in messages {
 for record in message.records {
 let payload = String(data: record.payload, encoding: .utf8) ?? "Unknown"
 print("NDEF Record type: \(record.typeNameFormat), payload: \(payload)")
 }
 }
}

func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
 if let readerError = error as? NFCReaderError {
 switch readerError.code {
 case .readerSessionInvalidationErrorUserCanceled:
 print("User cancelled scanning.")
 case .readerSessionInvalidationErrorSessionTimeout:
 print("Session timed out.")
 default:
 print("Session error: \(error.localizedDescription)")
 }
 }
}

Leyendo las etiquetas del ECM en la profundidad

Las etiquetas NFC suelen almacenar datos en formato NDEF. Un mensaje NDEF puede contener uno o más registros, cada uno con un tipo, identificador y carga útil. Los tipos de registro comunes incluyen (texto de la queja), (URLs), y ] (contenido rico.

Paginas de Registro de Parsing

Para interpretar la carga útil, inspeccionar los datos y :

func handleRecord(_ record: NFCNDEFPayload) {
 switch record.typeNameFormat {
 case .nfcWellKnown:
 if record.type == NFCTypeNameFormat.wellKnownTypeText {
 let textPayload = String(data: record.payload, encoding: .utf8) ?? ""
 print("Text: \(textPayload)")
 } else if record.type == NFCTypeNameFormat.wellKnownTypeURI {
 let uriPayload = String(data: record.payload, encoding: .utf8) ?? ""
 print("URI: \(uriPayload)")
 }
 case .absoluteURI:
 let absoluteURI = String(data: record.payload, encoding: .utf8) ?? ""
 print("Absolute URI: \(absoluteURI)")
 default:
 print("Unhandled type name format: \(record.typeNameFormat)")
 }
}

Escribir etiquetas de ECM

Empezando con iOS 13, puedes escribir mensajes de NDEF a etiquetas compatibles usando (o los combinados con capacidad de escritura).El proceso requiere en .

Aquí hay un ejemplo compacto usando con soporte de escritura:

func writeToTag() {
 let session = NFCNDEFReaderSession(delegate: self, queue: .main, invalidateAfterFirstRead: false)
 session.alertMessage = "Hold your iPhone near the tag to write."
 session.begin()
}

func readerSession(_ session: NFCNDEFReaderSession, didDetect tags: [NFCNDEFTag]) {
 guard let tag = tags.first else { return }
 session.connect(to: tag) { error in
 guard error == nil else { return }
 // Create an NDEF message
 let payload = NFCNDEFPayload(
 format: .nfcWellKnown,
 type: NFCTypeNameFormat.wellKnownTypeURI.data(using: .utf8)!,
 identifier: Data(),
 payload: "https://example.com".data(using: .utf8)!
 )
 let message = NFCNDEFMessage(records: [payload])
 tag.queryNDEFStatus { status, _, error in
 guard status == .readWrite, error == nil else { return }
 tag.writeNDEF(message) { error in
 if error == nil {
 print("Write successful.")
 }
 session.invalidate()
 }
 }
 }
}

Nota: La escritura funciona sólo con etiquetas re-escrito (Tipo 2, Tipo 4, etc.). Algunas etiquetas (como MIFARE Classic) pueden requerir un manejo especial o pueden ser bloqueadas.

Lectura de la etiqueta de fondo

Con el modo de acceso adecuado y el modo de fondo habilitado, su aplicación puede detectar etiquetas NFC incluso cuando no está en primer plano. El sistema lanza o retoma su aplicación y entrega los datos de la etiqueta a través de los mismos métodos de delegado. Usted debe asegurarse de que su aplicación maneja la etiqueta rápidamente, ya que la sesión de antecedentes tiene tiempo limitado.

Puntos clave para la lectura de fondo:

• Añada el modo de fondo .
• El sistema mostrará una alerta con el nombre de su aplicación y opcionalmente el que usted estableció antes de que finalice la sesión.
• Si la aplicación no se ejecuta en el fondo, el sistema la lanzará al fondo durante unos segundos.

func readerSession(_ session: NFCReaderSession, didDetect tags: [NFCISO7816Tag]) {
 guard let tag = tags.first else { return }
 session.connect(to: tag) { error in
 guard error == nil else { return }
 // Send SELECT command
 let selectCommand = NFCISO7816APDU(
 instructionClass: 0x00,
 instructionCode: 0xA4,
 p1Parameter: 0x04,
 p2Parameter: 0x00,
 data: Data([0xA0, 0x00, 0x00, 0x03, 0x00, 0x00]),
 expectedResponseLength: -1
 )
 tag.sendCommand(apdu: selectCommand) { response, sw1, sw2, error in
 if error == nil {
 print("Command succeeded, SW1=\(sw1), SW2=\(sw2)")
 }
 }
 }
}