java - 使用 MifareUltralight.transceive 在 Android 中设置 NTAG213 密码崩溃，没有抛出异常

Question

我试图在我的空 NTAG213 标签上设置密码，但是当我开始编写 PACK 和 PWD 时，我的应用程序崩溃了，没有抛出任何异常。我确实让我的应用程序足够远，可以编写有效的 NDEF 消息并读取它们，看来我也可以写入其他配置页面(2Ah 和 29h 用于配置密码保护)。但是，当我开始编写 PACK 时，我的应用程序崩溃了，但没有抛出我期望来自 MifareUltralight.transceive(byte[] data) 的 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();
}

编辑:我不知道昨天 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.java:761)

我不太明白为什么会这样，因为首先我连接了 mifare，等待它连接，进行收发，关闭我的 mifare，然后调用 ndef.connect() block 。这是否意味着在我的收发 block 中的某处出现异常，因此我没有正确关闭 mifare 并且无法打开 ndef？那会很奇怪，因为即使我只用 Exception 换掉了 IOException，我也没有得到异常，所以我捕获了每个异常，不管确切的类型是什么。

编辑 2:我现在明白为什么应用程序会在这个异常中结束。代码确实有效，我的标签现在受密码保护，当我再次尝试使用相同的标签时，我不会先进行身份验证，因此收发失败，导致 try-catch block 中断，该 block 也包含关闭功能。我通过使 MifareUltralight 对象在整个线程中可用并在运行 ndef.connect() 部分之前关闭它来解决这个问题。

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

提前致谢。

Answer 1

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

因此，一定要打电话

mifare.connect();

在您收发任何命令之前，还要确保在此之后再次关闭实例:

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