设置NTAG213密码在Android与MifareUltralight.transceive崩溃，没有异常抛出

Question

我正在尝试在我的空NTAG213标签上设置密码，但是当我开始编写PACK和PWD时，我的应用程序就崩溃了，没有异常被抛出。我确实让我的应用程序足够远，可以写入有效的NDEF消息并读取这些消息，似乎我也可以写入其他配置页面（2Ah和29h用于配置密码保护）。当我开始编写PACK时，我的应用程序崩溃了，但没有抛出我期望从MifareUltralight.transceive（byte[]data）得到的IOExc的值。

这是我的 writeAndProtect 方法的源代码：

private void writeAndProtectTag(final Intent intent, final String message) {
    // Run the entire process in its own thread as MifareUltralight.transceive(byte[] data);
    // Should not be run in main thread according to <https://developer.android.com/reference/android/nfc/tech/MifareUltralight.html#transceive(byte[])>
    (new Thread(new Runnable() {
        // Password has to be 4 characters
        // Password Acknowledge has to be 2 characters
        byte[] pwd      = "-_bA".getBytes();
        byte[] pack     = "cC".getBytes();

        @Override
        public void run() {
            // Store tag object for use in MifareUltralight and Ndef
            Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
            MifareUltralight mifare = null;
            int debugCounter = 0;

            // Whole process is put into a big try-catch trying to catch the transceive's IOException
            try {
                mifare = MifareUltralight.get(tag);

                mifare.connect();
                while(!mifare.isConnected());
                byte[] response;

                // Authenticate with the tag first
                // In case it's already been locked
                try {
                    response = mifare.transceive(new byte[]{
                            (byte) 0x1B, // PWD_AUTH
                            pwd[0], pwd[1], pwd[2], pwd[3]
                    });
                    // Check if PACK is matching expected PACK
                    // This is a (not that) secure method to check if tag is genuine
                    if ((response != null) && (response.length >= 2)) {
                        byte[] packResponse = Arrays.copyOf(response, 2);
                        if (!(pack[0] == packResponse[0] && pack[1] == packResponse[1])) {
                            Toast.makeText(ctx, "Tag could not be authenticated:\n" + packResponse.toString() + "≠" + pack.toString(), Toast.LENGTH_LONG).show();
                        }
                    }
                }catch(IOException e){
                    e.printStackTrace();
                }

                // Get Page 2Ah
                response = mifare.transceive(new byte[] {
                        (byte) 0x30, // READ
                        (byte) 0x2A  // page address
                });
                // configure tag as write-protected with unlimited authentication tries
                if ((response != null) && (response.length >= 16)) {    // read always returns 4 pages
                    boolean prot = false;                               // false = PWD_AUTH for write only, true = PWD_AUTH for read and write
                    int authlim = 0;                                    // 0 = unlimited tries
                    mifare.transceive(new byte[] {
                            (byte) 0xA2, // WRITE
                            (byte) 0x2A, // page address
                            (byte) ((response[0] & 0x078) | (prot ? 0x080 : 0x000) | (authlim & 0x007)),    // set ACCESS byte according to our settings
                            0, 0, 0                                                                         // fill rest as zeros as stated in datasheet (RFUI must be set as 0b)
                    });
                }
                // Get page 29h
                response = mifare.transceive(new byte[] {
                        (byte) 0x30, // READ
                        (byte) 0x29  // page address
                });
                // Configure tag to protect entire storage (page 0 and above)
                if ((response != null) && (response.length >= 16)) {  // read always returns 4 pages
                    int auth0 = 0;                                    // first page to be protected
                    mifare.transceive(new byte[] {
                            (byte) 0xA2, // WRITE
                            (byte) 0x29, // page address
                            response[0], 0, response[2],              // Keep old mirror values and write 0 in RFUI byte as stated in datasheet
                            (byte) (auth0 & 0x0ff)
                    });
                }

                // Send PACK and PWD
                // set PACK:
                mifare.transceive(new byte[] {
                        (byte)0xA2,
                        (byte)0x2C,
                        pack[0], pack[1], 0, 0  // Write PACK into first 2 Bytes and 0 in RFUI bytes
                });
                // set PWD:
                mifare.transceive(new byte[] {
                        (byte)0xA2,
                        (byte)0x2B,
                        pwd[0], pwd[1], pwd[2], pwd[3] // Write all 4 PWD bytes into Page 43
                });

            } catch (IOException e) {
                //Trying to catch any exception that may be thrown
                e.printStackTrace();
            } catch (Exception e) {
                //Trying to catch any exception that may be thrown
                e.printStackTrace();
            }
            try {
                mifare.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            // Generate NdefMessage to be written onto the tag
            NdefMessage msg = null;
            try {
                NdefRecord r1 = NdefRecord.createMime("text/plain", message.getBytes("UTF-8"));
                NdefRecord r2 = NdefRecord.createApplicationRecord("com.example.myname.myapplication");
                msg = new NdefMessage(r1, r2);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }

            // Generate Ndef object from tag object
            Ndef ndef = Ndef.get(tag);

            // Connect NDEF, write message and close connection
            try {
                ndef.connect();
                ndef.writeNdefMessage(msg);
                ndef.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (FormatException e) {
                e.printStackTrace();
            } catch (Exception e) {
                //Trying to catch any exception that may be thrown
                e.printStackTrace();
            }
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    btn.setImageResource(R.drawable.arrow_red);
                    tv.setText("");
                }
            });
            curAction = "handle";
        }
    })).start();
}

编辑：我不知道昨天Android Studio是否有问题，或者您的解决方案是否实际上改变了情况，但是我更新了代码，现在出现以下异常：

E/AndroidRuntime: FATAL EXCEPTION: Thread-4
                       Process: com.example.alex.nfcapppce, PID: 25918
                       java.lang.IllegalStateException: Close other technology first!
                           at android.nfc.Tag.setConnectedTechnology(Tag.java:458)
                           at android.nfc.tech.BasicTagTechnology.connect(BasicTagTechnology.java:78)
                           at android.nfc.tech.Ndef.connect(Ndef.java)
                           at com.example.alex.nfcapppce.MainActivity$2.run(MainActivity.java:194) //The line saying ndef.connect()
                           at java.lang.Thread.run(Thread.html" target="_blank">java:761)

我不太明白为什么会发生这种情况，因为首先我连接了

编辑2:我现在知道为什么应用程序会在这个异常中结束了。代码实际上工作了，我的标签现在受密码保护，当我再次尝试使用同一个标签时，我没有先进行身份验证，因此收发失败，导致包含关闭函数的try-catch块中断。我通过使MifareUltralight对象在整个线程中可用并在运行ndef.connect()的部分之前关闭它来解决这个问题。

现在我（希望）的最后一个问题是：我可以使用Ndef类进行身份验证吗？我的Ndef对象似乎没有身份验证方法，所以我必须再次使用MifareUltralight。但是当我关闭MifareUltralight连接以打开Ndef连接时，身份验证没有丢失吗？或者我唯一的可能是使用Strings在受密码保护的标签上写入Ndef消息，将它们切成4字节的页面，然后使用MifareUltralight.writepage（byte[]addr， byte[]data）一个接一个地写入它们？当我使用上面更新的时候，我从ndef.writeNdeMessage（）得到了一个IOExc的异常，我想这意味着关闭mi的连接也未授权给我。

提前感谢。

Answer 1

使用MifareUltralight技术时，您永远不会连接到标签。因此，调用 mifare.transceive（） 将导致异常。您的应用崩溃，因为此异常可能不是 IOException 的实例（您会在代码中捕获该实例）。

因此，一定要打电话

mifare.connect();

在收发任何命令之前，并确保在此之后再次关闭实例：

try {
    mifare.close();
} catch (Exception ignored) {}