Compreender o Quadro NFC do Núcleo do iOS para a Intercâmbio de Dados sem Contacto

O framework do iOS Core NFC permite aos desenvolvedores criar aplicativos que leiam e escrevam tags Near Field Communication (NFC), permitindo uma troca de dados rápida, segura e direta sem contato. À medida que a tecnologia NFC se torna um padrão básico no varejo, transporte, controle de acesso e muito mais, entender como integrar esse framework em seu aplicativo iOS abre a porta para experiências de usuários modernas e livres de atrito. Este artigo fornece um guia abrangente e pronto para a produção do framework Core NFC, desde a configuração inicial e gerenciamento de sessões até recursos avançados e implantação real.

Uma breve visão geral do NFC no iOS

A Near Field Communication (NFC) é uma norma de conectividade sem fios de curto alcance que opera a 13,56 MHz. A Apple introduziu o framework Core NFC com iOS 11, originalmente limitado à leitura de etiquetas NFC Data Exchange Format (NDEF). As versões posteriores do iOS expandiram os recursos: o iOS 13 adicionou suporte para escrever etiquetas NDEF e leitura de tags de fundo, enquanto o iOS 14 e posteriormente melhorou a compatibilidade com etiquetas ISO-7816, ISO-15693 e FeliCa. Hoje, o Core NFC está disponível no iPhone 7 e, posteriormente, alcançando milhões de usuários.

A NFC opera a uma distância de alguns centímetros, tornando-a ideal para cenários “tap-to-interact”, como pagamento, lealdade, bilheteria e verificação de identidade. O framework abstrai a comunicação de rádio de baixo nível, permitindo aos desenvolvedores se concentrarem na análise e manipulação dos dados recebidos das etiquetas NFC.

Capacidades de Framework NFC de base

A compreensão do que o quadro NFC principal pode (e não pode) fazer é essencial antes de iniciar o desenvolvimento.

  • Lendo tags da NEF – Leia mensagens da NDEF de tags NFC compatíveis (ISO 14443, FeliCa e ISO 15693 em versões posteriores do iOS).
  • NDEF tag writing – Escreva mensagens NDEF para etiquetas regraváveis (iOS 13+).
  • Leitura de tags de fundo – Detectar e ler etiquetas NFC mesmo quando seu aplicativo está em segundo plano (iOS 13+).
  • ISO-7816 e ISO-14443-4 comunicação – Trocar unidades de dados de protocolo de aplicação (APDUs) para pagamentos, controle de acesso e aplicações de ID do governo.
  • Manutenção personalizada do comando – Envie comandos proprietários para MIFARE e outros cartões, desde que tenha os direitos necessários do provedor MIFARE/NXP.

Limitações notáveis: O núcleo NFC não suporta a troca de dados peer-to-peer, a emulação de cartões baseada em host (HCE) não está disponível no iOS (Apple Pay usa um caminho de elementos seguros diferente), e o controlador NFC está exclusivamente disponível para o aplicativo de primeiro plano, a menos que use leitura de fundo.

Pré-requisitos do Projeto

Requisitos de hardware e software

  • Um iPhone 7 ou posterior (iPhone SE, 6s e modelos anteriores não possuem suporte de hardware NFC para Core NFC).
  • Xcode 12 ou posterior (para suporte de leitura e escrita de fundo).
  • O iOS 13+ é recomendado para capacidades completas de escrita e de fundo do NDEF, embora a leitura sozinho funcione de volta ao iOS 11.
  • Uma conta do Apple Developer (contas gratuitas podem testar em dispositivos físicos; a distribuição comercial requer uma conta paga).

Habilitando o direito do Núcleo NFC

No seu projeto Xcode, navegue para Assinando as Capacidades do & e adicione a capacidade de Leitura de Etiquetas de Comunicação de Campo Próximo[. Esta ação adiciona o arquivo de direito necessário e garante que seu aplicativo pode solicitar acesso a hardware NFC.

Configurar a sua aplicação para o NFC

Chave Info.plist

Adicione a tecla à sua com uma string explicando por que sua aplicação precisa de acesso NFC. Esta string é apresentada ao usuário durante a primeira sessão NFC. Por exemplo:

<key>NFCReaderUsageDescription</key>
<string>This app uses NFC to read your loyalty cards and event tickets.</string>

Se o seu aplicativo escreve em tags, você também deve adicionar a chave (iOS 13+).

Modos de Fundo

Para ativar a leitura de tags de fundo, habilite o Modos de fundo capacidade e verifique Leitura de tags de comunicação de campo próximo. Além disso, seu aplicativo deve implementar o e estar preparado para lidar com detecção de tags enquanto estiver em segundo plano.

Ciclo de vida da sessão NFC principal

O objeto central para ler as tags NDEF é . Uma sessão começa quando você chama e termina automaticamente quando uma tag é lida (se é verdadeira) ou quando você invalida manualmente. Durante a sessão, o sistema mostra um alerta de interface fornecido pelo sistema, dizendo ao usuário para segurar o dispositivo perto de uma tag.

Iniciando uma sessão

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()
 }
}

Lidando com os Callbacks Delegados

Aplicar os dois métodos de delegação necessários:

  • – Chamado quando uma ou mais mensagens NDEF são lidas com sucesso. O método recebe uma matriz de objetos , cada um contendo registros.
  • – Chamado quando a sessão terminar, seja porque uma tag foi lida ou ocorreu um erro (por exemplo, usuário cancelado, tag não suportada). Use este método para repor o estado e informar o usuário.

Implementação de exemplo:

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)")
 }
 }
}

Lendo etiquetas NDEF na profundidade

As etiquetas NFC normalmente armazenam dados no formato NDEF. Uma mensagem NDEF pode conter um ou mais registros, cada um com um tipo, identificador e carga útil. Os tipos de registros comuns incluem (texto simples), (URLs) e (conteúdo rico).

Processando as Cargas Paúveis dos Registros

Para interpretar a carga útil, inspecione os dados e :

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)")
 }
}

Gravando as Marcas do NDEF

A partir do iOS 13, você pode escrever mensagens NDEF para tags compatíveis usando (ou o combinado com capacidade de escrita). O processo requer o ] em .

Aqui está um exemplo compacto usando com suporte de escrita:

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: A escrita funciona apenas com etiquetas regraváveis (Tipo 2, Tipo 4, etc.). Algumas etiquetas (como o MIFARE Classic) podem exigir manipulação especial ou podem estar bloqueadas.

Leitura de Etiquetas de Fundo

Com o modo de direito e de fundo apropriado habilitado, seu aplicativo pode detectar etiquetas NFC mesmo quando não está em primeiro plano. O sistema lança ou retoma seu aplicativo e entrega os dados da tag através dos mesmos métodos de delegada. Você deve garantir que seu aplicativo lida com a tag rapidamente, uma vez que a sessão de fundo tem tempo limitado.

Pontos-chave para leitura de fundo:

  • Adicionar o modo de fundo Ler as etiquetas de comunicação de campo próximo.
  • O sistema irá mostrar um alerta com o nome do seu aplicativo e opcionalmente o que você definir antes da sessão terminar.
  • Se o aplicativo não estiver rodando em segundo plano, o sistema irá lançá-lo em segundo plano por alguns segundos.

NFC avançado: Comunicação ISO-7816 e APDU

Para aplicações que requerem comunicação direta com um elemento seguro dentro de um cartão (por exemplo, terminais de pagamento, cartões de trânsito, IDs do governo), use objetos ou . Isto permite enviar e receber comandos APDU, conforme definido na norma ISO-7816-4.

Exemplo: Comunicar com um cartão MIFARE DESFire

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)")
 }
 }
 }
}

O uso avançado de etiquetas ISO-7816 requer uma compreensão profunda do conjunto de comandos do cartão alvo. A documentação do Apple Core NFC fornece a referência completa da API.

Considerações sobre Segurança e Privacidade

O NFC no iOS é projetado com privacidade e segurança na vanguarda:

  • Consentimento do usuário – Uma sessão NFC sempre começa com um alerta do sistema visível.O usuário deve manter o dispositivo ativamente perto de uma tag; o aplicativo não pode escanear silenciosamente.
  • Encriptação de dados – Para operações sensíveis (por exemplo, pagamento), o controlador NFC comunica com o elemento seguro dentro do iPhone. Os dados da tag em si não são criptografados pela framework – seu aplicativo deve aplicar sua própria criptografia se necessário.
  • Validação de conteúdo de tags – Sempre valide a carga útil das tags NFC antes de usá-la. Dados malformados podem ser explorados.
  • Título e plist keys – A Apple analisa a sua descrição de utilização; a utilização incorrecta de capacidades NFC pode levar à rejeição do aplicativo.

Casos de uso real-mundo expandidos

O núcleo NFC permite uma grande variedade de interações sem contato:

  • Pagos sem contacto e lealdade – Integrar-se aos terminais de pagamento equipados com NFC existentes ou utilizar o quadro para ler cartões de valor armazenados e pontos de fidelidade.
  • Controlo de acesso – Substituir as chaves físicas pelo aplicativo iOS. Leia credenciais de crachás de acesso ou escreva direitos de acesso temporários às etiquetas.
  • Transporte público – Implementar recursos tap-to-read para passes de trânsito (por exemplo, etiquetas FeliCa no Japão; ISO-14443 em muitos sistemas europeus).
  • Acondicionamento inteligente – Deixe os usuários tocarem em pacotes de produtos para visualizar informações de autenticidade, datas de validade ou conteúdo promocional.
  • Pontos de informação sobre o museu e o varejo – Coloque etiquetas NFC ao lado de exposições ou produtos para fornecer conteúdo de mídia rico quando grampeado.
  • Medical e farmacêutico – Leia pulseiras de paciente ou rótulos de medicação para verificar a identidade e dosagem.

Para inspiração, ver A sessão WWDC 2020 da Apple sobre NFC e o código de amostragem oficial do núcleo NFC.

Otimização de desempenho e melhores práticas

  • Reduzir a duração da sessão – Definir para verdadeiro quando você só precisa de uma tag. Para digitalização em lote, gerenciar o ciclo de vida da sessão cuidadosamente para evitar a drenagem da bateria.
  • Use uma fila dedicada – Passe uma fila serial para o inicializador de sessão para evitar bloquear o thread principal durante o processamento de tags.
  • Handle NFCReaderError graciosamente – Verifique sempre se há erros como e forneça mensagens claras ao usuário.
  • Teste com etiquetas reais – O simulador não suporta NFC. Use uma variedade de etiquetas físicas (Tipo 2, Tipo 4, MIFARE) para garantir a compatibilidade.
  • Evite loops de votação – Uma vez que uma tag é detectada, processe-a imediatamente e termine a sessão. A digitalização repetida da mesma tag é desnecessária.

Resolver Problemas Comuns

ProblemSolution
NFCNDEFReaderSession.readingAvailable returns falseEnsure the device is iPhone 7 or later. Check that the NFC capability is enabled in Xcode and the entitlement file is present.
Session starts but no tag is detectedMake sure the tag is NDEF‑formatted and placed correctly near the top‑back of the iPhone (near the camera). Some thick cases can interfere.
App rejected due to missing usage descriptionAdd both NFCReaderUsageDescription and (if writing) NFCWriteAccessUsageDescription to Info.plist.
Background reading not triggeringEnable the “Near Field Communication Tag Reading” background mode. Also ensure the app was terminated properly (not force‑killed).
Writing fails with “tag not writable”Check if the tag is locked or read‑only. Some tags require a password before writing.

O futuro da NFC no iOS

A Apple continua a evoluir Core NFC com cada versão iOS. Os recursos rumores e emergentes incluem suporte expandido para ISO-15693 (usado em livros de biblioteca e algumas etiquetas de inventário), melhorias potenciais de leitura e integração mais profunda com Wallet e Express Mode. Os desenvolvedores devem monitorar as notas de lançamento Core NFC para permanecerem atuais.

Conclusão

O sistema iOS Core NFC é uma ferramenta robusta e bem concebida para adicionar intercâmbio de dados sem contacto a qualquer aplicativo iPhone. Ao dominar o ciclo de vida da sessão, o manuseio do NDEF e a comunicação avançada de tags, você pode fornecer tudo, desde simples digitalização de cartões de negócio até sofisticados sistemas de controle de acesso. Comece construindo um leitor mínimo, depois expanda com recursos de escrita e de fundo conforme as exigências de casos de uso. Com milhões de iPhones equipados com NFC no campo, a oportunidade de criar experiências perfeitas e baseadas em torneiras nunca foi tão grande.