Java 使用MifareUltralight.transceive在Android中设置NTAG213密码时崩溃，未引发异常

我试图在空的NTAG213标签上设置密码，但是当我开始写包和PWD时，我的应用程序崩溃了，没有异常抛出。我确实让我的应用程序写了足够多的有效NDEF消息并阅读了这些消息，似乎我还可以写入其他配置页面（2Ah和29h用于配置密码保护）。不过，当我开始编写软件包时，我的应用程序崩溃了，但没有抛出MifareUltralight.transceive（byte[]数据）中预期的IOException

以下是我的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();
}

我不太明白为什么会发生这种情况，因为首先我连接mifare，等待它连接，进行收发，关闭mifare，然后调用带有ndef.connect（）的块。这是否意味着在我的收发模块的某个地方出现异常，因此我没有正确关闭mifare，无法打开ndef？这会很奇怪，因为我没有得到异常，即使我将IOException换成了just exception，所以我捕获每个异常，不管是什么类型的异常

编辑2：我现在了解应用程序以此异常结束的原因。代码实际上是有效的，我的标签现在受到密码的保护，当我再次尝试使用同一个标签时，我不会首先进行身份验证，因此收发器失败，导致try-catch块中断，该块也包含close函数。我通过使MifareUltralight对象在整个线程中可用并在运行ndef.connect（）部分之前关闭它来解决这个问题

现在我（希望）的最后一个问题是：我可以使用Ndef类进行身份验证吗？我的Ndef对象似乎没有身份验证方法，因此我不得不再次使用MifareUltralight进行验证。但是，当我关闭MifareUltralight连接以打开Ndef连接时，身份验证是否没有丢失？或者，我唯一可以在密码保护的标签上使用 字符串，将它们剪切成4字节的页面，然后使用MifareUltralight.writepage（byte[]addr，byte[]data）逐个写入它们？当我使用上面更新的文件时，我从ndef.writeNdefMessage（）得到一个IOException，我想这意味着关闭mifare连接也会取消我的权限

---

提前感谢。

使用MifareUltralight技术时，您从未连接到标签。因此，调用

mifare.transceive（）

将导致异常。您的应用程序崩溃，因为此异常可能不是

IOException

的实例（您可能会在代码中捕获到）

因此，一定要打电话

mifare.connect();

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

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

---

你能澄清一下“崩溃，没有异常抛出”是什么意思吗？你的应用程序是冻结还是崩溃（关闭）？在后一种情况下，您可能确实得到了一个异常（只是不是您试图捕获的异常）…应用程序实际上关闭（应用程序停止工作屏幕），而我没有捕获正确的异常。设置密码和确认之前的收发器命令也不起作用，不知何故它们不会崩溃。当我扫描我试图用NFC TagInfo应用程序写入的标记时，其configbytes中的位未设置。我知道程序在mifare.transceive（新字节[]{（字节）0xA2，（字节）0x2C，pack[0]，pack[1]时崩溃，0，0//将数据包写入前2个字节，将0写入RFUI字节}）；因为我在代码中有调试行，当应用程序崩溃时，我收到的最后一条调试消息就是这个命令上面的消息。谢谢你的回答，我明天早上再次访问PC时会尝试。非常感谢你在这方面的帮助，我现在更新了第一篇帖子（实际上更新了两次）。我的最后一个问题是：我可以避免使用MifareUltralight.writePage（addr，data）来验证和编写ndef吗？我真的更喜欢使用Ndef类编写ndefMessage。嗨，我使用上面的代码段使用密码保护NFC标记，但我在这里得到了TagLostException:

response=mifare.transceive（新字节[]{（字节）0x1B，//PWD_AUTH PWD[0]，PWD[1]，PWD[2]，PWD[3]}）try {
    mifare.close();
} catch (Exception ignored) {}