IT. Expert System.

Android Reference

MifareClassic


android.nfc.tech

Class MifareClassic

  • All Implemented Interfaces:
    TagTechnology, Closeable, AutoCloseable


    public final class MifareClassic
    extends Object
    Provides access to MIFARE Classic properties and I/O operations on a Tag.

    Acquire a MifareClassic object using get(android.nfc.Tag).

    MIFARE Classic is also known as MIFARE Standard.

    MIFARE Classic tags are divided into sectors, and each sector is sub-divided into blocks. Block size is always 16 bytes (BLOCK_SIZE. Sector size varies.

    • MIFARE Classic Mini are 320 bytes (SIZE_MINI), with 5 sectors each of 4 blocks.
    • MIFARE Classic 1k are 1024 bytes (SIZE_1K), with 16 sectors each of 4 blocks.
    • MIFARE Classic 2k are 2048 bytes (SIZE_2K), with 32 sectors each of 4 blocks.
    • MIFARE Classic 4k} are 4096 bytes (SIZE_4K). The first 32 sectors contain 4 blocks and the last 8 sectors contain 16 blocks.

    MIFARE Classic tags require authentication on a per-sector basis before any other I/O operations on that sector can be performed. There are two keys per sector, and ACL bits determine what I/O operations are allowed on that sector after authenticating with a key. authenticateSectorWithKeyA(int, byte[]) and authenticateSectorWithKeyB(int, byte[]).

    Three well-known authentication keys are defined in this class: KEY_DEFAULT, KEY_MIFARE_APPLICATION_DIRECTORY, KEY_NFC_FORUM.

    • KEY_DEFAULT is the default factory key for MIFARE Classic.
    • KEY_MIFARE_APPLICATION_DIRECTORY is the well-known key for MIFARE Classic cards that have been formatted according to the MIFARE Application Directory (MAD) specification.
    • KEY_NFC_FORUM is the well-known key for MIFARE Classic cards that have been formatted according to the NXP specification for NDEF on MIFARE Classic.

      Implementation of this class on a Android NFC device is optional. If it is not implemented, then MifareClassic will never be enumerated in Tag.getTechList(). If it is enumerated, then all MifareClassic I/O operations will be supported, and Ndef.MIFARE_CLASSIC NDEF tags will also be supported. In either case, NfcA will also be enumerated on the tag, because all MIFARE Classic tags are also NfcA.

      Note: Methods that perform I/O operations require the android.Manifest.permission#NFC permission.

    • Field Detail

      • KEY_DEFAULT

        public static final byte[] KEY_DEFAULT
        The default factory key.
      • KEY_MIFARE_APPLICATION_DIRECTORY

        public static final byte[] KEY_MIFARE_APPLICATION_DIRECTORY
        The well-known key for tags formatted according to the MIFARE Application Directory (MAD) specification.
      • KEY_NFC_FORUM

        public static final byte[] KEY_NFC_FORUM
        The well-known key for tags formatted according to the NDEF on MIFARE Classic specification.
      • TYPE_UNKNOWN

        public static final int TYPE_UNKNOWN
        A MIFARE Classic compatible card of unknown type
        See Also:
        Constant Field Values
      • SIZE_1K

        public static final int SIZE_1K
        Tag contains 16 sectors, each with 4 blocks.
        See Also:
        Constant Field Values
      • SIZE_2K

        public static final int SIZE_2K
        Tag contains 32 sectors, each with 4 blocks.
        See Also:
        Constant Field Values
      • SIZE_4K

        public static final int SIZE_4K
        Tag contains 40 sectors. The first 32 sectors contain 4 blocks and the last 8 sectors contain 16 blocks.
        See Also:
        Constant Field Values
      • SIZE_MINI

        public static final int SIZE_MINI
        Tag contains 5 sectors, each with 4 blocks.
        See Also:
        Constant Field Values
      • BLOCK_SIZE

        public static final int BLOCK_SIZE
        Size of a MIFARE Classic block (in bytes)
        See Also:
        Constant Field Values
    • Method Detail

      • get

        public static MifareClassic get(Tag tag)
        Get an instance of MifareClassic for the given tag.

        Does not cause any RF activity and does not block.

        Returns null if MifareClassic was not enumerated in Tag.getTechList(). This indicates the tag is not MIFARE Classic compatible, or this Android device does not support MIFARE Classic.

        Parameters:
        tag - an MIFARE Classic compatible tag
        Returns:
        MIFARE Classic object
      • getType

        public int getType()
        Return the type of this MIFARE Classic compatible tag.

        One of TYPE_UNKNOWN, TYPE_CLASSIC, TYPE_PLUS or TYPE_PRO.

        Does not cause any RF activity and does not block.

        Returns:
        type
      • getSize

        public int getSize()
        Return the size of the tag in bytes

        One of SIZE_MINI, SIZE_1K, SIZE_2K, SIZE_4K. These constants are equal to their respective size in bytes.

        Does not cause any RF activity and does not block.

        Returns:
        size in bytes
      • isEmulated

        public boolean isEmulated()
        Return true if the tag is emulated, determined at discovery time. These are actually smart-cards that emulate a MIFARE Classic interface. They can be treated identically to a MIFARE Classic tag.
      • getSectorCount

        public int getSectorCount()
        Return the number of MIFARE Classic sectors.

        Does not cause any RF activity and does not block.

        Returns:
        number of sectors
      • getBlockCount

        public int getBlockCount()
        Return the total number of MIFARE Classic blocks.

        Does not cause any RF activity and does not block.

        Returns:
        total number of blocks
      • getBlockCountInSector

        public int getBlockCountInSector(int sectorIndex)
        Return the number of blocks in the given sector.

        Does not cause any RF activity and does not block.

        Parameters:
        sectorIndex - index of sector, starting from 0
        Returns:
        number of blocks in the sector
      • blockToSector

        public int blockToSector(int blockIndex)
        Return the sector that contains a given block.

        Does not cause any RF activity and does not block.

        Parameters:
        blockIndex - index of block to lookup, starting from 0
        Returns:
        sector index that contains the block
      • sectorToBlock

        public int sectorToBlock(int sectorIndex)
        Return the first block of a given sector.

        Does not cause any RF activity and does not block.

        Parameters:
        sectorIndex - index of sector to lookup, starting from 0
        Returns:
        block index of first block in sector
      • authenticateSectorWithKeyA

        public boolean authenticateSectorWithKeyA(int sectorIndex,
                                         byte[] key)
                                           throws IOException
        Authenticate a sector with key A.

        Successful authentication of a sector with key A enables other I/O operations on that sector. The set of operations granted by key A key depends on the ACL bits set in that sector. For more information see the MIFARE Classic specification on http://www.nxp.com.

        A failed authentication attempt causes an implicit reconnection to the tag, so authentication to other sectors will be lost.

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        sectorIndex - index of sector to authenticate, starting from 0
        key - 6-byte authentication key
        Returns:
        true on success, false on authentication failure
        Throws:
        TagLostException - if the tag leaves the field
        IOException - if there is an I/O failure, or the operation is canceled
      • authenticateSectorWithKeyB

        public boolean authenticateSectorWithKeyB(int sectorIndex,
                                         byte[] key)
                                           throws IOException
        Authenticate a sector with key B.

        Successful authentication of a sector with key B enables other I/O operations on that sector. The set of operations granted by key B depends on the ACL bits set in that sector. For more information see the MIFARE Classic specification on http://www.nxp.com.

        A failed authentication attempt causes an implicit reconnection to the tag, so authentication to other sectors will be lost.

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        sectorIndex - index of sector to authenticate, starting from 0
        key - 6-byte authentication key
        Returns:
        true on success, false on authentication failure
        Throws:
        TagLostException - if the tag leaves the field
        IOException - if there is an I/O failure, or the operation is canceled
      • readBlock

        public byte[] readBlock(int blockIndex)
                         throws IOException
        Read 16-byte block.

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        blockIndex - index of block to read, starting from 0
        Returns:
        16 byte block
        Throws:
        TagLostException - if the tag leaves the field
        IOException - if there is an I/O failure, or the operation is canceled
      • writeBlock

        public void writeBlock(int blockIndex,
                      byte[] data)
                        throws IOException
        Write 16-byte block.

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        blockIndex - index of block to write, starting from 0
        data - 16 bytes of data to write
        Throws:
        TagLostException - if the tag leaves the field
        IOException - if there is an I/O failure, or the operation is canceled
      • increment

        public void increment(int blockIndex,
                     int value)
                       throws IOException
        Increment a value block, storing the result in the temporary block on the tag.

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        blockIndex - index of block to increment, starting from 0
        value - non-negative to increment by
        Throws:
        TagLostException - if the tag leaves the field
        IOException - if there is an I/O failure, or the operation is canceled
      • decrement

        public void decrement(int blockIndex,
                     int value)
                       throws IOException
        Decrement a value block, storing the result in the temporary block on the tag.

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        blockIndex - index of block to decrement, starting from 0
        value - non-negative to decrement by
        Throws:
        TagLostException - if the tag leaves the field
        IOException - if there is an I/O failure, or the operation is canceled
      • transfer

        public void transfer(int blockIndex)
                      throws IOException
        Copy from the temporary block to a value block.

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        blockIndex - index of block to copy to
        Throws:
        TagLostException - if the tag leaves the field
        IOException - if there is an I/O failure, or the operation is canceled
      • restore

        public void restore(int blockIndex)
                     throws IOException
        Copy from a value block to the temporary block.

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        blockIndex - index of block to copy from
        Throws:
        TagLostException - if the tag leaves the field
        IOException - if there is an I/O failure, or the operation is canceled
      • transceive

        public byte[] transceive(byte[] data)
                          throws IOException
        Send raw NfcA data to a tag and receive the response.

        This is equivalent to connecting to this tag via NfcA and calling NfcA.transceive(byte[]). Note that all MIFARE Classic tags are based on NfcA technology.

        Use getMaxTransceiveLength() to retrieve the maximum number of bytes that can be sent with transceive(byte[]).

        This is an I/O operation and will block until complete. It must not be called from the main application thread. A blocked call will be canceled with IOException if close() is called from another thread.

        Requires the android.Manifest.permission#NFC permission.

        Throws:
        IOException
        See Also:
        NfcA.transceive(byte[])
      • getMaxTransceiveLength

        public int getMaxTransceiveLength()
        Return the maximum number of bytes that can be sent with transceive(byte[]).
        Returns:
        the maximum number of bytes that can be sent with transceive(byte[]).
      • setTimeout

        public void setTimeout(int timeout)
        Set the transceive(byte[]) timeout in milliseconds.

        The timeout only applies to transceive(byte[]) on this object, and is reset to a default value when close() is called.

        Setting a longer timeout may be useful when performing transactions that require a long processing time on the tag such as key generation.

        Requires the android.Manifest.permission#NFC permission.

        Parameters:
        timeout - timeout value in milliseconds
      • getTimeout

        public int getTimeout()
        Get the current transceive(byte[]) timeout in milliseconds.

        Requires the android.Manifest.permission#NFC permission.

        Returns:
        timeout value in milliseconds
      • isConnected

        public boolean isConnected()
        Description copied from interface: TagTechnology
        Helper to indicate if I/O operations should be possible.

        Returns true if TagTechnology.connect() has completed, and TagTechnology.close() has not been called, and the Tag is not known to be out of range.

        Does not cause RF activity, and does not block.

        Specified by:
        isConnected in interface TagTechnology
        Returns:
        true if I/O operations should be possible


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 3786 / . Delta: 0.05433 с