Premiers pas avec Core NFC

Online Coding Courses for Kids

La communication en champ proche (NFC) est une technologie permettant aux appareils sans fil à courte portée de partager des données avec d’autres appareils ou de déclencher des actions sur ces appareils. Construit à l’aide d’un champ de fréquence radio, il permet aux appareils qui n’ont pas le pouvoir de stocker de petites données tout en permettant à d’autres appareils alimentés de lire ces données.

Le matériel NFC est intégré aux appareils iOS et watchOS depuis plusieurs années maintenant. En fait, Apple Pay utilise cette technologie pour interagir avec les terminaux de paiement dans les magasins. Cependant, les développeurs ne pouvaient pas utiliser le matériel NFC avant iOS 11.

Apple a augmenté son jeu NFC dans iOS 13 en présentant NFC de base. Avec cette nouvelle technologie, vous pouvez programmer des appareils iOS pour interagir avec le monde connecté autour d’eux de nouvelles façons. Ce didacticiel vous montrera quelques-unes des façons dont vous pouvez utiliser cette technologie. En cours de route, vous apprendrez à:

  • Écrivez des informations standard sur une balise NFC.
  • Lisez ces informations.
  • Enregistrez des informations personnalisées dans une balise.
  • Modifiez les données déjà trouvées sur une balise.
Note importante: Pour effectuer toutes les étapes de ce didacticiel, vous aurez besoin des éléments suivants:

  • Un appareil iOS physique
  • Un compte développeur Apple
  • Matériel NFC à partir duquel vous pouvez lire et écrire. De nombreux détaillants en ligne proposent des étiquettes NFC à des prix raisonnables. Vous pouvez généralement obtenir un pack de tags NFC pour environ 10 $ USD. Recherchez quelque chose dans la description qui indique qu’il est programmable ou répertorie sa capacité de stockage, généralement de 300 à 500 octets. Tout appareil avec cette capacité approximative est plus qu’acceptable pour ce didacticiel.

Commencer

Pour commencer, téléchargez les projets de didacticiel à l’aide du Télécharger les documents en haut ou en bas de ce didacticiel et ouvrez le projet de démarrage dans le entrée dossier. Avec l’application de projet, vous apprendrez à:

  • Configurez une balise NFC comme «emplacement».
  • Scannez une balise d’emplacement pour voir son nom et le journal des visiteurs.
  • Ajoutez un visiteur à une balise d’emplacement.

Construisez et exécutez. Vous verrez ce qui suit:

Application en cours d'exécution après le téléchargement de documents

Écrire sur votre première balise

Pour commencer, sélectionnez le NeatoCache projet dans le Navigateur de projet. Ensuite aller à Signature et capacité et sélectionnez + Capacité. Choisir Lecture d’étiquette de communication en champ proche de la liste.

Montrer comment ajouter le droit NFC à votre projet
Cela garantira que le profil d’approvisionnement de votre application est configuré pour utiliser NFC.

Ensuite, ouvrez votre Info.plist et ajoutez l’entrée suivante:

  • Clé: Confidentialité – Description de l’utilisation de l’analyse NFC
  • Valeur: Utilisez NFC pour lire et écrire des données

Vous avez besoin de cette entrée pour communiquer à vos utilisateurs à quoi vous utilisez la fonction NFC, ainsi que pour vous conformer aux exigences d’Apple concernant l’utilisation de NFC dans votre application.

Ensuite, vous allez ajouter une fonction qui peut effectuer les différentes tâches NFC que votre application va gérer. Ouvert NFCUtility.swift et ajoutez les alias d’importation et de type suivants en haut du fichier:

import CoreNFC

typealias NFCReadingCompletion = (Result) -> Void
typealias LocationReadingCompletion = (Result) -> Void

Vous devez importer CoreNFC de travailler avec NFC. Les alias de type offrent les fonctionnalités suivantes:

  • NFCReadingCompletion pour effectuer des tâches de lecture de balises génériques.
  • LocationReadingCompletion pour lire une balise configurée comme emplacement

Ensuite, ajoutez les propriétés et la méthode suivantes à NFCUtility:

// 1
private var session: NFCNDEFReaderSession?
private var completion: LocationReadingCompletion?

// 2
static func performAction(
  _ action: NFCAction,
  completion: LocationReadingCompletion? = nil
) {
  // 3
  guard NFCNDEFReaderSession.readingAvailable else {
    completion?(.failure(NFCError.unavailable))
    print("NFC is not available on this device")
    return
  }

  shared.action = action
  shared.completion = completion
  // 4
  shared.session = NFCNDEFReaderSession(
    delegate: shared.self,
    queue: nil,
    invalidateAfterFirstRead: false)
  // 5
  shared.session?.alertMessage = action.alertMessage
  // 6
  shared.session?.begin()
}

Ne vous inquiétez pas si vous obtenez une erreur de compilation à ce stade en raison du non-respect de NFCNDEFReaderSessionDelegate, vous allez résoudre ce problème momentanément.

Voici ce que vous venez de faire:

  1. Vous ajoutez session et completion propriétés pour stocker la session de lecture NFC active et son bloc d’achèvement.
  2. Ajoutez une fonction statique comme point d’entrée pour vos tâches de lecture et d’écriture NFC. Vous utiliserez un accès de style singleton pour cette fonction et pour NFCUtility, en général.
  3. Assurez-vous que l’appareil prend en charge la lecture NFC. Sinon, complétez avec une erreur.
  4. Créé un NFCNDEFReaderSession, qui représente la session de lecture active. Vous définissez également le délégué pour qu’il soit averti des divers événements de la session de lecture NFC.
  5. Vous définissez le alertMessage sur la session afin qu’il affiche ce texte à l’utilisateur, dans le modal NFC.
  6. Démarrez la session de lecture. Lorsqu’il est appelé, un modal présentera à l’utilisateur toutes les instructions que vous avez définies à l’étape précédente.

Comprendre le NDEF

Notez que le code ci-dessus introduit un autre acronyme, NDEF, qui signifie Format d’échange de données NFC. Il s’agit d’un format standardisé pour écrire ou lire sur un appareil NFC. Les deux morceaux de NDEF que vous utiliserez sont:

  • Enregistrement NDEF: Contient votre valeur de charge utile, telle qu’une chaîne, une URL ou des données personnalisées. Il contient également des informations à propos cette valeur de charge utile, comme la longueur et le type. Cette information est la NFCNDEFPayload dans CoreNFC.
  • Message NDEF: Il s’agit de la structure de données qui contient les enregistrements NDEF. Il peut y avoir un ou plusieurs enregistrements NDEF dans un message NDEF.

Détection des balises

Maintenant que vous avez configuré votre NFCReaderSession, il est temps de se conformer NFCUtility en tant que son délégué, afin que vous puissiez être informé des divers événements qui se produisent pendant une session de lecture.

Ajoutez le code suivant au bas de NFCUtility.swift:

// MARK: - NFC NDEF Reader Session Delegate
extension NFCUtility: NFCNDEFReaderSessionDelegate {
  func readerSession(
    _ session: NFCNDEFReaderSession,
    didDetectNDEFs messages: [NFCNDEFMessage]
  ) {
    // Not used
  }
}

Vous ajouterez plus à cette extension en une seconde, mais notez ici que vous ne ferez rien avec readerSession(_:didDetectNDEFs:) dans ce tutoriel. Vous ne faites que l’ajouter ici car il est obligatoire de se conformer au protocole délégué.

Plus vous interagissez avec la technologie NFC, plus vous voyez la possibilité de rencontrer des erreurs à différentes étapes du processus de lecture et d’écriture. Ajoutez la méthode suivante à votre nouvelle extension pour capturer ces erreurs:

private func handleError(_ error: Error) {
  session?.alertMessage = error.localizedDescription
  session?.invalidate()
}

La première ligne de code devrait vous être familière. Il présentera le message d’erreur à l’utilisateur dans la vue modale NFC. En cas d’erreur, vous invalidez également la session pour la terminer et autorisez l’utilisateur à interagir à nouveau avec l’application.

Ensuite, ajoutez la méthode suivante à l’extension pour traiter les erreurs de votre session de lecture NFC:

func readerSession(
  _ session: NFCNDEFReaderSession,
  didInvalidateWithError error: Error
) {
  if let error = error as? NFCReaderError,
    error.code != .readerSessionInvalidationErrorFirstNDEFTagRead &&
      error.code != .readerSessionInvalidationErrorUserCanceled {
    completion?(.failure(NFCError.invalidated(message: 
      error.localizedDescription)))
  }

  self.session = nil
  completion = nil
}

L’ajout de cette méthode déléguée supprimera toutes les erreurs de compilation que vous avez rencontrées jusqu’à présent.

Enfin, ajoutez cette dernière méthode à votre extension pour faire face à la détection éventuelle de tags NFC:

func readerSession(
  _ session: NFCNDEFReaderSession,
  didDetect tags: [NFCNDEFTag]
) {
  guard 
    let tag = tags.first,
    tags.count == 1 
    else {
      session.alertMessage = """
        There are too many tags present. Remove all and then try again.
        """
      DispatchQueue.global().asyncAfter(deadline: .now() + .milliseconds(500)) {
        session.restartPolling()
      }
      return
  }
}

Ici, vous implémentez la méthode que vous appellerez lorsque votre session détectera que vous avez analysé une balise.

En règle générale, vous vous attendez à ce que les utilisateurs aient une seule balise suffisamment proche de leur téléphone, mais vous devez tenir compte de plusieurs balises à proximité. Si vous le détectez, vous arrêterez l’analyse et alerterez l’utilisateur. Après avoir affiché le message, vous redémarrerez la session de lecture et laissez votre utilisateur réessayer.

Gestion de la balise

Une fois que vous savez que vous avez une balise, vous voudrez probablement en faire quelque chose. Ajoutez le code suivant après votre guard déclaration dans readerSession(_:didDetect:):

// 1
session.connect(to: tag) { error in
  if let error = error {
    self.handleError(error)
    return
  }

  // 2
  tag.queryNDEFStatus { status, _, error in
    if let error = error {
      self.handleError(error)
      return
    }

    // 3
    switch (status, self.action) {
    case (.notSupported, _):
      session.alertMessage = "Unsupported tag."
      session.invalidate()
    case (.readOnly, _):
      session.alertMessage = "Unable to write to tag."
      session.invalidate()
    case (.readWrite, .setupLocation(let locationName)):
      self.createLocation(name: locationName, with: tag)
    case (.readWrite, .readLocation):
      return
    default:
      return
    }
  }
}

Voici ce que vous faites dans le code ci-dessus:

  1. Connectez-vous à la balise détectée, en utilisant le courant NCFNDEFReaderSession. Vous devez effectuer cette étape pour effectuer une lecture ou une écriture sur la balise. Une fois connecté, il appellera son gestionnaire d’achèvement, avec toute erreur qui pourrait se produire.
  2. Recherchez le statut NDEF de la balise pour voir si le périphérique NFC est pris en charge. Le statut doit être readWrite aux fins de votre NeatoCache app.
  3. Basculez l’état et l’action NFC et déterminez ce qui doit être fait en fonction de leurs valeurs. Ici, vous essayez de configurer un tag pour avoir un nom de lieu à l’aide createLocation(name:with:), qui n’existe pas encore, vous rencontrerez donc une erreur de compilation. Pas de soucis cependant, vous l’ajouterez dans un instant. De même, le readLocation l’action n’est pas non plus gérée pour le moment.

Création de la charge utile

Jusqu’à présent, vous avez travaillé à trouver une balise, à vous y connecter et à interroger son statut. Pour terminer la configuration de l’écriture dans une balise, ajoutez le bloc de code suivant à la fin de NFCUtility.swift:

// MARK: - Utilities
extension NFCUtility {
  func createLocation(name: String, with tag: NFCNDEFTag) {
    // 1
    guard let payload = NFCNDEFPayload
      .wellKnownTypeTextPayload(string: name, locale: Locale.current) 
      else {
        handleError(NFCError.invalidated(message: "Could not create payload"))
        return
    }

    // 2
    let message = NFCNDEFMessage(records: [payload])

    // 3
    tag.writeNDEF(message) { error in
      if let error = error {
        self.handleError(error)
        return
      }

      self.session?.alertMessage = "Wrote location data."
      self.session?.invalidate()
      self.completion?(.success(Location(name: name)))
    }
  }
}

Voici ce que vous faites dans le code ci-dessus:

  1. Créer un texte NFCNDEFPayload. Comme indiqué précédemment, cela s’apparente à un enregistrement NDEF.
  2. Faire un nouveau NFCNDEFMessage avec la charge utile afin que vous puissiez l’enregistrer sur le périphérique NFC.
  3. Enfin, écrivez le message dans la balise.

Utilisation des types de charge utile NDEF

NFCNDEFPayload prend en charge plusieurs types de données différents. Dans cet exemple, vous utilisez wellKnownTypeTextPayload(string:locale:). Il s’agit d’un type de données assez simple qui utilise la chaîne et les paramètres régionaux actuels de l’appareil. Quelques-uns des autres types de données contiennent des informations plus complexes. Voici la liste complète:

  • Vide
  • Bien connu
  • Type de média MIME
  • URI absolu
  • Externe
  • Inconnue
  • Inchangé
  • Réservé
Remarque: Ce didacticiel couvre Bien connu et Inconnue. Pour en savoir plus sur les autres types, consultez les liens répertoriés à la fin de ce didacticiel.

Notez également qu’un type peut avoir des sous-types. Bien connu, par exemple, a les sous-types de Texte et URI.

Vous vous rapprochez vraiment! Il ne vous reste plus qu’à brancher votre interface utilisateur à votre nouveau code. Aller à AdminView.swift et remplacez le code suivant:

Button(action: {
}) {
  Text("Save Location…")
}
.disabled(locationName.isEmpty)

Avec celui-ci:

Button(action: {
  NFCUtility.performAction(.setupLocation(locationName: self.locationName)) { _ in
    self.locationName = ""
  }
}) {
  Text("Save Location…")
}
.disabled(locationName.isEmpty)

Cela fera un appel pour configurer votre emplacement avec le texte trouvé dans le champ de texte.

Construisez et exécutez, basculez vers le Admin onglet de l’application, entrez un nom et sélectionnez Enregistrer l’emplacement….

Vous verrez ce qui suit:

Votre application à la recherche d'une balise NFC pour numériser et écrire des données

Remarque: N’oubliez pas que vous devrez utiliser un appareil physique et disposer d’une balise NFC prenant en charge les capacités d’écriture.

Une fois que vous avez placé votre téléphone sur votre tag NFC, vous verrez un message indiquant que votre position a bien été enregistrée.

L'application a réussi à enregistrer les données de localisation dans une balise NFC

Lire la balise

Génial! Maintenant que vous disposez d’une application qui peut écrire une chaîne dans une balise, vous êtes prêt à prendre en charge la lecture. Revenir à NFCUtility.swift et trouvez le code suivant dans readerSession(_:didDetect:).

case (.readWrite, .readLocation):
  return

Maintenant, remplacez-le par ceci:

case (.readWrite, .readLocation):
  self.readLocation(from: tag)

Il est temps de mettre cela en œuvre readLocation(from:) méthode. Ajoutez ce qui suit à la Utilitaires extension qui contient createLocation(name:with:):

func readLocation(from tag: NFCNDEFTag) {
  // 1
  tag.readNDEF { message, error in
    if let error = error {
      self.handleError(error)
      return
    }
    // 2
    guard 
      let message = message,
      let location = Location(message: message) 
      else {
        self.session?.alertMessage = "Could not read tag data."
        self.session?.invalidate()
        return
    }
    self.completion?(.success(location))
    self.session?.alertMessage = "Read tag."
    self.session?.invalidate()
  }
}

Cet ajout devrait vous sembler quelque peu familier, car il est très similaire à la façon dont vous avez écrit sur la balise.

  1. Tout d’abord, vous lancez la lecture d’une balise. S’il peut être lu, il renverra tous les messages qu’il trouvera.
  2. Ensuite, vous essayez de créer un Emplacement sur les données du message, si vous en avez un. Cela utilise un initialiseur personnalisé qui accepte un NFCNDEFMessage et en retire le nom. Si vous êtes curieux, vous pouvez trouver cet initialiseur dans LocationModel.swift.

Enfin, ouvrez VisitorView.swift, et en scanSection, remplacez le code suivant:

Button(action: {
}) {
  Text("Scan Location Tag…")
}

Avec celui-ci:

Button(action: {
  NFCUtility.performAction(.readLocation) { location in
    self.locationModel = try? location.get()
  }
}) {
  Text("Scan Location Tag…")
}

Vous êtes prêt à lire les données de votre balise. Construisez et exécutez.

Dans l’onglet Visiteurs, appuyez sur Balise d’emplacement de numérisation…. Vous verrez ce qui suit, avec le nom de votre emplacement maintenant dans l’interface utilisateur:

L'application scanne et lit une balise NFC avec des données de localisation

Écriture de différents types de données

Bien que l’écriture de chaînes puisse fonctionner parfaitement dans certains cas d’utilisation, vous pouvez constater que vous souhaitez écrire d’autres types de données dans les balises.

Pour vous y préparer, ajoutez ce qui suit à NFCUtility.swift, dans le Utilitaires extension:

private func read(
  tag: NFCNDEFTag,
  alertMessage: String = "Tag Read",
  readCompletion: NFCReadingCompletion? = nil
) {
  tag.readNDEF { message, error in
    if let error = error {
      self.handleError(error)
      return
    }

    // 1
    if let readCompletion = readCompletion,
       let message = message {
      readCompletion(.success(message))
    } else if 
      let message = message,
      let record = message.records.first,
      let location = try? JSONDecoder()
        .decode(Location.self, from: record.payload) {
      // 2
      self.completion?(.success(location))
      self.session?.alertMessage = alertMessage
      self.session?.invalidate()
    } else {
      self.session?.alertMessage = "Could not decode tag data."
      self.session?.invalidate()
    }
  }
}

Cette nouvelle méthode de lecture des tags sera le point d’entrée pour la plupart de vos activités à partir de maintenant. Comme vous pouvez le voir, il lit toujours la balise, comme auparavant. Cependant, une fois qu’il aura lu la balise, il fera l’une des deux choses suivantes:

  1. Appelez un gestionnaire d’achèvement et transmettez-lui le message. Cela sera utile pour chaîner plusieurs tâches NFC ensemble.
  2. Décodez la charge utile afin de pouvoir analyser les enregistrements de la balise. Vous y reviendrez dans un instant.

Écriture de données personnalisées au lieu de chaînes

À ce stade, vous êtes prêt à convertir l’application de l’écriture de chaînes en une balise à l’écriture de données personnalisées dans une balise. Ajoutez ce qui suit à la Utilitaires extension:

private func createLocation(_ location: Location, tag: NFCNDEFTag) {
  read(tag: tag) { _ in
    self.updateLocation(location, tag: tag)
  }
}

Il s’agit de votre nouvelle fonction pour créer une balise avec un emplacement. Vous pouvez voir qu’il utilise le nouveau read(tag:alsertMessage:readCompletion:) pour démarrer le processus et appelle une nouvelle fonction pour mettre à jour un emplacement sur une balise, et aussi un nouveau updateLocation(_:tag:) que vous allez mettre en œuvre momentanément.

Étant donné que vous remplacez la façon dont vous écrivez les informations de localisation dans une balise, supprimez createLocation(name:with:) au début de la NFCUtility l’extension, car elle n’est plus nécessaire. Mettez également à jour votre code dans readerSession(_:didDetect:) de cela:

case (.readWrite, .setupLocation(let locationName)):
  self.createLocation(name: locationName, with: tag)

… Aux éléments suivants:

case (.readWrite, .setupLocation(let locationName)):
  self.createLocation(Location(name: locationName), tag: tag)

Ensuite, ajoutez cette méthode après createLocation(_:tag:):

private func updateLocation(
  _ location: Location,
  withVisitor visitor: Visitor? = nil,
  tag: NFCNDEFTag
) {
  // 1
  var alertMessage = "Successfully setup location."
  var tempLocation = location
  
  // 2
  let jsonEncoder = JSONEncoder()
  guard let customData = try? jsonEncoder.encode(tempLocation) else {
    self.handleError(NFCError.invalidated(message: "Bad data"))
    return
  }
  // 3
  let payload = NFCNDEFPayload(
    format: .unknown,
    type: Data(),
    identifier: Data(),
    payload: customData)
  // 4
  let message = NFCNDEFMessage(records: [payload])
}

Voici ce que vous faites dans le code ci-dessus:

  1. Créez un message d’alerte par défaut et un emplacement temporaire. Vous y reviendrez plus tard.
  2. Encode le Location struct passé à la fonction. Cela convertira le modèle en brut Data. Ceci est important, car c’est la façon dont vous écrivez n’importe quel type personnalisé dans une balise NFC.
  3. Créez une charge utile capable de gérer vos données. Cependant, vous utilisez maintenant unknown comme format. Pour ce faire, vous devez définir type et identifiant à vider Data, tandis que le payload L’argument héberge le modèle décodé réel.
  4. Ajoutez la charge utile à un message nouvellement créé.

Dans l’ensemble, cela ne devrait pas sembler trop différent que lorsque vous avez enregistré une chaîne dans une balise – vous ajoutez simplement une étape supplémentaire pour convertir un type de données Swift en quelque chose qu’une balise comprend.

Vérification de la capacité des balises

Pour terminer l’écriture des données dans la balise, ajoutez le bloc de code suivant dans updateLocation(_:withVisitor:tag):

tag.queryNDEFStatus { _, capacity, _ in
  // 1
  guard message.length <= capacity else {
    self.handleError(NFCError.invalidPayloadSize)
    return
  }

  // 2
  tag.writeNDEF(message) { error in
    if let error = error {
      self.handleError(error)
      return
    }
    
    if self.completion != nil {
      self.read(tag: tag, alertMessage: alertMessage)
    }
  }
}

La fermeture ci-dessus tente d'interroger l'état NDEF actuel, puis:

  1. S'assure que l'appareil dispose de suffisamment d'espace de stockage pour stocker l'emplacement. N'oubliez pas que les balises NFC ont souvent une capacité de stockage extrêmement limitée par rapport aux appareils que vous connaissez peut-être.
  2. Écrivez le message dans la balise.

Construisez, exécutez et configurez un emplacement comme vous l'avez fait ci-dessus. Vous pouvez utiliser la même balise d'avant si vous le souhaitez, car votre nouveau code remplacera toutes les données précédemment enregistrées.

Lecture de vos données personnalisées

À ce stade, si vous essayez de lire votre balise, vous obtiendrez une erreur. Les données enregistrées ne sont plus un type bien connu. Pour résoudre ce problème, remplacez le code suivant dans readerSession(_:didDetect:):

case (.readWrite, .readLocation):
  self.readLocation(from: tag)

...avec ça:

case (.readWrite, .readLocation):
  self.read(tag: tag)

Créez, exécutez et scannez votre tag. Parce que tu appelles read(tag:alertMessage:readCompletion:) sans aucun bloc d'achèvement, il décodera les données trouvées dans le premier enregistrement du message.

Modification du contenu

La dernière exigence pour cette application est d'enregistrer un journal des personnes qui ont visité cet emplacement. Votre application dispose d'une fonctionnalité inutilisée déjà présente dans l'interface utilisateur qui permet aux utilisateurs d'entrer leur nom et de l'ajouter à une balise. Le travail que vous avez accompli jusqu'à présent rendra le reste de la configuration trivial. Vous pouvez déjà lire et écrire des données sur une balise, donc la modifier devrait être un jeu d'enfant pour vous.

Dans NFCUtility.swift, ajoutez ce code à updateLocation(_:withVisitor:tag:) juste après avoir créé tempLocation:

if let visitor = visitor {
  tempLocation.visitors.append(visitor)
  alertMessage = "Successfully added visitor."
}

Dans le code ci-dessus, vous vérifiez si un visiteur a été fourni. Si oui, vous l'ajoutez à l'emplacement visitors tableau.

Ensuite, ajoutez la méthode suivante à la Utilitaires extension:

private func addVisitor(_ visitor: Visitor, tag: NFCNDEFTag) {
  read(tag: tag) { message in
    guard 
      let message = try? message.get(),
      let record = message.records.first,
      let location = try? JSONDecoder()
        .decode(Location.self, from: record.payload) 
      else {
        return
    }

    self.updateLocation(location, withVisitor: visitor, tag: tag)
  }
}

Cette nouvelle méthode lira une balise, en recevra le message et tentera de décoder le Emplacement dessus.

Ensuite, dans readerSession(_:didDetect:), ajoutez un nouveau cas à votre instruction switch:

case (.readWrite, .addVisitor(let visitorName)):
  self.addVisitor(Visitor(name: visitorName), tag: tag)

Si l'utilisateur souhaite spécifiquement ajouter un visiteur, vous appellerez la fonction que vous avez ajoutée à l'étape précédente.

Il ne reste plus qu'à mettre à jour VisitorView.swift. Dans visitorSection, remplacez le code suivant:

Button(action: {
}) {
  Text("Add To Tag…")
}
.disabled(visitorName.isEmpty)

Avec celui-ci:

Button(action: {
  NFCUtility
    .performAction(.addVisitor(visitorName: self.visitorName)) { location in
      self.locationModel = try? location.get()
      self.visitorName = ""
    }
}) {
  Text("Add To Tag…")
}
.disabled(visitorName.isEmpty)

Créez et exécutez, puis accédez à l'onglet Visiteurs. Saisissez votre nom, puis sélectionnez Ajouter à la balise…. Après la numérisation, vous verrez l'emplacement mis à jour avec une liste de visiteurs trouvés sur la balise.

Une balise de localisation numérisée indiquant le nom de la localisation et une liste de visiteurs

Où aller en partant d'ici?

Vous pouvez télécharger la version complète du projet en utilisant le Télécharger les documents en haut ou en bas de ce didacticiel.

Vous devez maintenant être familiarisé avec les bases de NFC de base. Il y a encore beaucoup de choses à faire avec le framework qui n'étaient même pas mentionnées dans ce tutoriel. Par exemple, vous pouvez ajouter une lecture en arrière-plan des balises, ce qui peut permettre à vos utilisateurs d'interagir avec votre application sans avoir à l'ouvrir. Si vous avez utilisé l'application Raccourcis d'Apple pour automatiser vos appareils domestiques intelligents, cela devrait vous sembler familier. Vous pouvez en savoir plus sur cette opération ici: Ajout de la prise en charge de la lecture des balises d'arrière-plan.

Pour en savoir plus, consultez certaines de ces excellentes ressources:

Documentation NFC d'Apple est votre ressource de référence pour tout ce que Apple prend en charge dans la spécification NFC.

le Page d'accueil du forum NFC est le lieu de toutes les informations dont vous avez besoin sur NFC en général, et les spécifications qu'il définit.

Si vous avez des questions sur ce didacticiel, veuillez vous joindre à la discussion du forum ci-dessous!

Close Menu