What is NFC? Everything you need to know about NFC technology | NextPit

To

map text to NDEF

given |record:NDEFRecordInit| and |ndef|,
run these steps:

This is useful when clients specifically want to write text in a
[=well-known type record=].
Other options would be to use the value «`mime`»
with an explicit MIME type text type, which allows for
better differentiation, e.g. when using «`text/xml`», or
«`text/vcard`».

1. If |record|’s mediaType is not `undefined`,
   [= exception/throw =] a {{TypeError}} and abort these steps.
2. If the type of |record|’s data is not {{DOMString}} or
   {{BufferSource}}, [= exception/throw =] a {{TypeError}} and abort
   these steps.
3. Let |documentLanguage:string| be the [=document element=]’s
   lang attribute.
4. If |documentLanguage| is the empty string, set it to «`en`».
5. Let |language:string| be |record|’s lang if it [= map/exists =],
   or else to |documentLanguage|.
6. Switch on the type of |record|’s data:

   {{DOMString}}

   1. If |record|’s encoding is neither `undefined` nor
      «`utf-8`», [= exception/throw =] a {{TypeError}} and abort
      these steps.
   2. Let |encoding label:string| be «`utf-8`».

   {{BufferSource}}

   1. Let |encoding label:string| be |record|’s encoding if
      it [= map/exists =], or else «`utf-8`».
   2. If |encoding label| is not equal to «`utf-8`», «`utf-16`»,
      «`utf-16le`» or «`utf-16be`» [= exception/throw =] a
      {{TypeError}} and abort these steps.

7. Let |encoding name| be the [=encoding/name|name=]
   obtained
   from |encoding label|.
8. Let |header:byte| be a byte constructed the following way:
   1. If |encoding name| is equal to UTF-8, set bit `7` to the value
      `0`, or else set the value to `1`.
   2. Set bit `6` to the value `0` (reserved).
   3. Let |languageLength:octet| be the length of the
      |language| string.
   4. If |languageLength| cannot be stored in 6 bit
      (|languageLength| > 63), [= exception/throw =] a {{SyntaxError}}.
   5. Set bit `5` to bit `0` to |languageLength|.
9. Let |data:byte sequence| be an empty [= byte sequence =].
   1. Set the first byte (position 0) of |data| to |header|.
   2. Set position 1 (second byte) to position |languageLength|
      of |data| to |language|.
   3. Switch on the type of |record|’s data:

      {{DOMString}}

      1. Let |stream:byte stream| be the resulting
         byte stream of
         running UTF-8 encode on |record|’s data.
      2. Read bytes
         from |stream| into |data| (from position |languageLength| 1)
         until read
         returns end-of-stream.

      {{BufferSource}}

      1. Set bytes from |record|’s data into |data|
         (from position |languageLength| 1) .

10. Set |length:unsigned long| to the [=byte sequence/length=]
    of |data|.
11. 1. Set the |ndef|’s TNF field to `1` (
       [=well-known type record=]).
    2. Set the |ndef|’s TYPE field to «`T`» (`0x54`).
    3. Set the |ndef|’s PAYLOAD LENGTH field to |length|.
    4. If |length| > `0`, set the |ndef|’s PAYLOAD field
       to |data|.
12. Return |ndef|.

1. NFC Forum Type 1: This tag is based on the ISO/IEC 14443-3A
   (NFC-A). The tags are rewritable and can be
   configured to become read-only. Memory size can be between `96` bytes and
   `2` Kbytes. Communication speed is `106` kbit/s. In contrast to all other
   types, these tags have no anti-collision protection for dealing with multiple
   tags within the NFC field.
2. NFC Forum Type 2: This tag is based on the
   ISO/IEC 14443-3A (NFC-A). The tags are rewritable and can be configured
   to become read-only. Memory size can be between `48` bytes and `2` Kbytes.
   Communication speed is `106` kbit/s.
3. NFC Forum Type 3: This tag is based on the Japanese Industrial
   Standard (JIS) X 6319-4 (ISO/IEC 18092), commonly known as FeliCa. The tags are
   preconfigured to be either rewritable or read-only. Memory is `2` kbytes.
   Communication speed is `212` kbit/s or `424` kbit/s.
4. NFC Forum Type 4: This tag is based on the ISO/IEC 14443-4 A/B
   (NFC A, NFC B) and thus supports either NFC-A or NFC-B
   for communication. On top of that the tag may optionally support ISO-DEP
   (Data Exchange Protocol defined in ISO/IEC 14443 (ISO/IEC 14443-4:2008
   Part 4: Transmission protocol). The tags are preconfigured
   to be either rewritable or read-only. Variable memory, up to `32` kbytes.
   Supports three different communication speeds `106` or `212` or
   `424` kbit/s.
5. NFC Forum Type 5: This tag is based on ISO/IEC 15693 (NFC-V) and
   allows reading and writing an NDEF message on an ISO/IEC 15693 RF tag
   that is accessible by long range RFID readers as well. The NFC communication
   is limited to short distance and may use the Active Communication Mode of
   ISO/IEC 18092 where the sending peer generates the field which balances
   power consumption and improves link stability. Variable memory, up to `64` kbytes.
   Communication speed is `26.48` kbit/s.
6. MIFARE Standard: This tag, often sold under the brand names MIFARE
   Classic or MIFARE Mini, is based on the ISO/IEC 14443-3A (also known as NFC-A,
   as defined in ISO/IEC 14443-3:2021, Part 3: Initialization and anticollision).
   The tags are rewritable and can be configured to become read-only. Memory size
   can be between `320` and `4` kbytes. Communication speed is `106` kbit/s.

   MIFARE Standard is not an NFC Forum type and can only be read by devices
   using NXP hardware. Support for reading and writing to tags based on the
   MIFARE Standard is thus non-nominative, but the type is included
   due to the popularity and use in legacy systems.

To

parse an NDEF record

given |ndef| and |context:string| into a
|record:NDEFRecord|, run these steps:

1. Set |record|’s id to |ndef|’s |id:string|.
2. Set |record|’s lang to `null`.
3. Set |record|’s encoding to `null`.
4. If |ndef|’s |typeNameField:number| (TNF field) is `0`
   (empty record):
   1. Set |record|’s id to `null`.
   2. Set |record|’s recordType to «`empty`».
   3. Set |record|’s mediaType to `null`.
   4. Set |record|’s data to `null`.
5. If |ndef|’s |typeNameField| is `1` ([=well-known type record=]), then
   1. If |ndef|’s |type:string| is «`T`» (`0x54`),
      set |record| to the result of running
      parse an NDEF text record on |ndef|.
   2. If |ndef|’s |type:string| is «`U`» (`0x55`),
      set |record| to the result of running
      parse an NDEF URL record on |ndef|.
   3. If |ndef|’s |type:string| is «`Sp`» (`0x53` `0x70`),
      set |record| to the result of running
      parse an NDEF smart-poster record on |ndef|.
   4. If |ndef|’s |type:string| is «`s`» (`0x73`)
      and if |context| is equal to `»smart-poster»`,
      set |record| to the result of running
      parse a smart-poster size record on |ndef|.
   5. If |ndef|’s |type:string| is «`t`» (`0x74`)
      and if |context| is equal to `»smart-poster»`,
      set |record| to the result of running
      parse a smart-poster type record on |ndef|.
   6. If |ndef|’s |type:string| is «`act`» (`0x61` `0x63` `0x74`)
      and if |context| is equal to `»smart-poster»`,
      set |record| to the result of running
      parse a smart-poster action record on |ndef|.
   7. If running the validate local type steps on
      |ndef|’s |type:string| returns `true`,
      1. If |context| is not `»external»` or `»smart-poster»`,
         [= exception/throw =] a {{TypeError}} and abort these steps.
      2. Set |record| to the result of running
         parse a local type record on |ndef|.
   8. Otherwise [= exception/throw =] a {{TypeError}} and abort these
      steps.
6. If |ndef|’s |typeNameField| is `2` (MIME type record), then
   set |record| to the result of running
   parse an NDEF MIME type record on |ndef|, or make sure that
   the underlying platform provides equivalent values to the |record|
   object’s properties.
7. If |ndef|’s |typeNameField| is `3` (absolute-URL record),
   then set |record| to the result of running
   parse an NDEF absolute-URL record on |ndef|.
8. If |ndef|’s |typeNameField| is `4` (external type record),
   then set |record| to the result of running
   parse an NDEF external type record on |ndef|, or make sure that
   the underlying platform provides equivalent values to the |record|
   object’s properties.
9. If |ndef|’s |typeNameField| is `5` (unknown record)
   then set |record| to the result of running
   parse an NDEF unknown record on |ndef|, or make sure that the
   underlying platform provides equivalent values to the |record| object’s
   properties.
10. Otherwise [= exception/throw =] a {{TypeError}} and abort these steps.

is defined in [[NDEF-SMARTPOSTER]] to describe a
given web content as an NDEF record that contains an

NDEF message

as payload, including the following records:

• A single mandatory URI record that refers to the
  smart poster content.

  The [[NDEF-SMARTPOSTER]] states that applications SHALL use only the
  smart poster record if it is present in an NDEF message
  that also contains other URI records.

• Zero or more Text records that act as a title record
  related to the content. When there are more than one title record
  present, they MUST be with different language tags.
  Applications SHOULD select one title record for presentation
  to the end user.
• Zero or more MIME type records that act as icon record
  related to the content. The MIME type is usually «`image/jpg`»,
  «`image/png`», «`image/gif`», or even «`video/mpeg`».
  Applications SHOULD select one icon record for presentation
  to the end user.
• One optional type record that has a [=local type name=]
  «`t`» specific to smart poster and the PAYLOAD field
  contains a UTF-8 encoded MIME type for the content referred to by the
  URI record.
• One optional size record that has [=local type name=] «`s`»
  specific to smart poster and the PAYLOAD field contains
  a 4-byte 32 bit unsigned integer that denotes the size of the object
  referred to by the URL in the URI record of the
  smart poster.
• One optional action record that has a [=local type name=]
  «`act`» specific to smart poster and the PAYLOAD field
  contains a single byte, whose value has the following meaning:

  Value	Description
  0	Do the action
  1	Save for later
  2	Open for editing
  3..0xFF	Reserved for future use

  There is no default action on the smart poster content if the
  action record is missing.

  At the time of NDEF standardization the value `0` («do the action») was
  intended for use cases like send an SMS, make a call or launch browser.
  Similarly, the value `1`, («save the content for later processing») was
  intended for use cases like store the SMS in inbox, save the URL in
  bookmarks, or save the phone number to contacts. Also, the value `2`
  («open for editing») was meant to open the smart poster content with a
  default application for editing.

  Implementations don’t need to implement any standardized behavior for the
  actions defined here. In this API it’s up to the applications what actions
  they define (that may include the use cases above). However, Web NFC
  just provides the values.

• A smart poster MAY also contain other records, which can be
  handled in an application specific manner.

The

NDEFReader.makeReadOnly

method, when invoked, MUST run the

make an NFC tag permanently read-only

algorithm:

1. Let |p:Promise| be a new {{Promise}} object.
2. If not currently executing in the currently active top-level
   browsing context, then reject |p| with and
   {{«InvalidStateError»}} {{DOMException}} and return |p|.
3. Let |options:NDEFMakeReadOnlyOptions| be the second argument.
4. Let |signal:AbortSignal| be the |options|’ dictionary member
   of the same name if present, or `null` otherwise.
5. If |signal| is [= AbortSignal/aborted =], then reject |p|
   with |signal|’s [=AbortSignal/abort reason=] and return |p|.
6. If |signal| is not `null`, then
   
   add the following abort steps to |signal|:
   1. Run the abort a pending make read-only operation on the
      environment settings object.
7. [=promise/React=] to |p|:
   1. If |p| was settled (fulfilled or rejected), then clear the
      pending write tuple if it exists.
8. Return |p| and run the following steps in parallel:
   1. If the obtain permission steps return `false`, then
      reject |p| with a {{«NotAllowedError»}} {{DOMException}} and
      abort these steps.
   2. If there is no underlying NFC Adapter, or if a connection
      cannot be established, then reject |p| with a
      {{«NotSupportedError»}} {{DOMException}}
      and abort these steps.
   3. If the UA is not allowed to access the underlying NFC Adapter
      (e.g. a user preference), then reject |p| with a
      {{«NotReadableError»}} {{DOMException}}
      and abort these steps.
   4. An implementation MAY reject |p| with
      a {{«NotSupportedError»}} {{DOMException}}
      and abort these steps.

      The UA might abort at this point. The reasons for termination
      are implementation details. For example, the implementation
      might be unable to support the requested operation.

   5. Attempt to abort a pending make read-only operation.

      A make read-only operation replaces all previously configured
      make read-only operations.

   6. Set pending makeReadOnly tuple to (`this`, |p|).
   7. Run the start the NFC make read-only steps whenever an
      NFC tag |device| comes within communication range.

      If NFC is suspended, continue waiting until promise is
      aborted by the user or an NFC tag comes within
      communication range.

The

NDEFReader.write

method, when invoked, MUST run the

write a message

algorithm:

1. Let |p:Promise| be a new {{Promise}} object.
2. If not currently executing in the currently active top-level
   browsing context, then reject |p| with and
   {{«InvalidStateError»}} {{DOMException}} and return |p|.
3. Let |message:NDEFMessageSource| be the first argument.
4. Let |options:NDEFWriteOptions| be the second argument.
5. Let |signal:AbortSignal| be the |options|’ dictionary member
   of the same name if present, or `null` otherwise.
6. If |signal| is [= AbortSignal/aborted =], then reject |p|
   with |signal|’s [=AbortSignal/abort reason=] and return |p|.
7. If |signal| is not `null`, then
   
   add the following abort steps to |signal|:
   1. Run the abort a pending write operation on the
      environment settings object.
8. [=promise/React=] to |p|:
   1. If |p| was settled (fulfilled or rejected), then clear the
      pending write tuple if it exists.
9. Return |p| and run the following steps in parallel:
   1. If the obtain permission steps return `false`, then
      reject |p| with a {{«NotAllowedError»}} {{DOMException}} and
      abort these steps.
   2. If there is no underlying NFC Adapter, or if a connection
      cannot be established, then reject |p| with a
      {{«NotSupportedError»}} {{DOMException}}
      and abort these steps.
   3. If the UA is not allowed to access the underlying NFC Adapter
      (e.g. a user preference), then reject |p| with a
      {{«NotReadableError»}} {{DOMException}}
      and abort these steps.
   4. If pushing data is not supported by the underlying
      NFC Adapter, then reject |p| with a {{«NotSupportedError»}}
      {{DOMException}} and abort these steps.
   5. An implementation MAY reject |p| with
      a {{«NotSupportedError»}} {{DOMException}}
      and abort these steps.

      The UA might abort message write at this point. The reasons
      for termination are implementation details. For example, the
      implementation might be unable to support the requested
      operation.

   6. Let |output| be the notation for the NDEF message
      to be created by UA, as the result of invoking
      create NDEF message with |message|, `»»`, and `0`.
      If this throws an exception, reject |p| with that
      exception and abort these steps.
   7. Attempt to abort a pending write operation.

      A write replaces all previously configured write operations.

   8. Set `this`.[[WriteOptions]] to |options|.
   9. Set `this`.[[WriteMessage]] to |output|.
   10. Set pending write tuple to (`this`, |p|).
   11. Run the start the NFC write steps whenever an
       NFC tag |device| comes within communication range.

       If NFC is suspended, continue waiting until promise is
       aborted by the user or an NFC tag comes within
       communication range.

To

start the NFC write

, run these steps:

1. Let |p:Promise| be the pending write tuple‘s promise.
2. Let |writer| be the pending write tuple‘s writer.
3. Let |options:NDEFWriteOptions| be |writer|.[[WriteOptions]].
4. If the NFC tag in proximity range does not expose
   NDEF technology for formatting or writing, then
   reject |p| with a {{«NotSupportedError»}} {{DOMException}} and
   return |p|.
5. Verify that NFC is not suspended.
6. In case of success, run the following steps:
   1. If |device| is an NFC tag and if |options|’s overwrite is
      `false`, read the tag to check whether there are NDEF
      records on the tag. If yes, then reject |p| with a
      {{«NotAllowedError»}} {{DOMException}} and return |p|.
   2. Let |output:NDEFMessage| be |writer|.[[WriteMessage]].
   3. Initiate data transfer to |device| using
      |output| as buffer, using the NFC adapter
      in communication range with |device|.

      If the NFC tag in proximity range is unformatted and
      NDEF-formatable, format it and write |output| as
      buffer.

      Multiple adapters should be used sequentially by users.
      There is very little likelihood that a simultaneous tap
      will happen on two or multiple different and connected
      NFC adapters.
      If it happens, the user will likely need to repeat the
      taps until success, preferably one device at a time.
      The error here gives an indication that the operation
      needs to be repeated. Otherwise the user may think the
      operation succeeded on all connected NFC adapters.

   4. If the transfer fails, reject |p| with
      {{«NetworkError»}} {{DOMException}}
      and abort these steps.
   5. When the transfer has completed, resolve |p|.