在Android客户端接收到第一条消息后，命令包含无效的消息id:2

我使用MQTT在Android上实现了一些类似聊天的功能，并从MQTT中获取了一个可用的示例，并对其进行了一些更改，以获得一个监听器。从Android客户端到ActiveMQ Brocker建立连接。我还有一个带有@ResourceAdapter（“activemq.rar”）和MDB的JbossServer，以便在服务器端实现管理（在运行时创建新主题等）

我有一个关于Android Clien中的侦听器和发布器的问题。侦听器和订阅已设置。它运行良好，但仅适用于第一条消息（两种方式：从客户端发送到主题，从WebConsole发送到主题）。 在收到第二条消息时，Android客户端从服务器发出的侦听器onFailure:java.net.ProtocolException:Command中出现错误，该命令包含无效的消息id:2。当我尝试从客户端发送第二条消息时，也会发生相同的错误。 我附上了我的密码。 如果你能帮我解决这个错误，我将不胜感激

private void callBackConnect() {
    mqtt = new MQTT();
    mqtt.setClientId("android-mqtt-example");

    try {
        // mqtt.setHost("localhost", 1883);
        // mqtt.setHost("tcp://10.0.0.62", 5445);
        mqtt.setHost(sAddress);
        Log.d(TAG, "Address set: " + sAddress);
    } catch (URISyntaxException urise) {
        Log.e(TAG, "URISyntaxException connecting to " + sAddress + " - "
                + urise);
    }

    if (sUserName != null && !sUserName.equals("")) {
        mqtt.setUserName(sUserName);
        Log.d(TAG, "UserName set: [" + sUserName + "]");
    }

    if (sPassword != null && !sPassword.equals("")) {
        mqtt.setPassword(sPassword);
        Log.d(TAG, "Password set: [" + sPassword + "]");
    }

    // futureConnection = mqtt.futureConnection();
    progressDialogListener = ProgressDialog.show(this, "",
            "setListener...", true);
    progressDialogListener.setCanceledOnTouchOutside(true);

    callBackConnection = mqtt.callbackConnection();

    callBackConnection.listener(new Listener() {
        public void onConnected() {
            Log.i(TAG, "callBackconnect()->setListener:onConnected");
            // new AlertDialog.Builder(MQTTActivity.this)
            // .setMessage("Connected (listener)")
            // .setNeutralButton("OK", null).show();
            progressDialogListener.dismiss();
        }

        public void onDisconnected() {
            Log.i(TAG, "callBackconnect()->setListener:onDisconnected");
            // new AlertDialog.Builder(MQTTActivity.this)
            // .setMessage("Disconnected (listener)")
            // .setNeutralButton("OK", null).show();
            progressDialogListener.dismiss();
        }

        public void onFailure(Throwable arg0) {
            Log.i(TAG,
                    "callBackconnect()->setListener:onFailure:"
                            + arg0.toString());
            Log.e(TAG, arg0.toString());
            // new AlertDialog.Builder(MQTTActivity.this)
            // .setMessage("Failure (listener)")
            // .setNeutralButton("OK", null).show();
            progressDialogListener.dismiss();
        }

        public void onPublish(UTF8Buffer topic, Buffer msg, Runnable ack) {
            Log.i(TAG,
                    "callBackconnect()->setListener:onPublish(UTF8Buffer arg0, Buffer arg1, Runnable arg2)");
            // new AlertDialog.Builder(MQTTActivity.this)
            // .setMessage("Publish (listener)")
            // .setNeutralButton("OK", null).show();

            final String msgBody = msg.utf8().toString();
            final String topicBody = topic.utf8().toString();
            // Create runnable for posting
            mHandler.post(new Runnable() {
                public void run() {
                    updateReceiveETInUi(topicBody, msgBody);
                }
            });

            Log.i(TAG,
                    "callBackconnect()->setListener:onPublish(UTF8Buffer arg0, Buffer arg1, Runnable arg2):"
                            + topicBody + " : " + msgBody);

            if (msgBody.startsWith("REPLY: ")) {
                // Don't reply to your own reply
                Log.i(TAG,
                        "callBackconnect()->setListener:onPublish-> msgBody.startsWith REPLY");
            } else {
                try {
                    byte[] reply = "REPLY: Hello Back".getBytes();
                    callBackConnection.publish(sDestination, reply,
                            QoS.AT_MOST_ONCE, true, null);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    });

    // callBackConnection.resume();
    progressDialogConn = ProgressDialog.show(this, "", "Connecting...",
            true, true);
    callBackConnection.connect(new Callback<Void>() {
        public void onFailure(Throwable value) {
            Log.i(TAG,
                    "callBackconnect()->connect->.onFailure : "
                            + value.toString());
            Log.e(TAG,
                    "callBackconnect()->connect->.onFailure : "
                            + value.toString());
            // new AlertDialog.Builder(MQTTActivity.this)
            // .setMessage(value.toString())
            // .setNeutralButton("OK", null).show();
            progressDialogConn.dismiss();
        }
        public void onSuccess(Void v) {
            Log.i(TAG, "callBackconnect()->connect->onSuccess(Void v): "
                    + v.TYPE.toString());
            // new
            // AlertDialog.Builder(MQTTActivity.this).setMessage("Connected (callback)")
            // .setNeutralButton("OK", null).show();
            progressDialogConn.dismiss();
        }
        public void onSuccess(UTF8Buffer topic, Buffer payload, Runnable ack) {
            // You can now process a received message from a topic.
            // Once process execute the ack runnable.
            Log.i(TAG,
                    topic.toString()
                            + "callBackconnect()->connect->.onSuccess(UTF8Buffer topic, Buffer payload, Runnable ack)");
            ack.run();
        }

    });


    if (sDestination.equals("")) {
        Log.i(TAG, "Destination must be provided");
    } else {
        callBackubSubcribe();

    }
}

private void callBackubSubcribe() {

    topics[0] = new Topic(sDestination, QoS.AT_LEAST_ONCE);
    // Topic[] topics = { new Topic(sDestination, QoS.AT_LEAST_ONCE) };
    Log.i(TAG, "topics[0]");

    for (int i = 0; i < topics.length; i++) {
        Log.i(TAG, "callBackubSubcribe topics: " + topics[i].toString());
    }

    progressDialogSub = ProgressDialog.show(this, "", "Subscribing...",
            true);
    progressDialogSub.setCanceledOnTouchOutside(true);

    Log.i(TAG, "callBackubSubcribe()-> TRY to subscribe(topics)");
    callBackConnection.subscribe(topics, new Callback<byte[]>() {
        public void onFailure(Throwable value) {
            Log.i(TAG,
                    "callBackubSubcribe->subscribe:onFailure:"
                            + value.toString());
            // new AlertDialog.Builder(MQTTActivity.this)
            // .setMessage(value.toString())
            // .setNeutralButton("OK", null).show();
            progressDialogSub.dismiss();
        }

        public void onSuccess(Void v) {
            Log.i(TAG, "callBackubSubcribe()->connect->.onSuccess");
            // new AlertDialog.Builder(MQTTActivity.this)
            // .setMessage("Connected (callback)")
            // .setNeutralButton("OK", null).show();
            progressDialogSub.dismiss();
        }

        @Override
        public void onSuccess(byte[] arg0) {
            Log.i(TAG,
                    "callBackubSubcribe()->connect->.onSuccess(byte[] arg0): "
                            + arg0.getClass().toString());
            progressDialogSub.dismiss();
        }
    });
}

private void callBackConnect（）{
mqtt=新的mqtt（）；
setClientId（“android mqtt示例”）；
试一试{
//mqtt.setHost（“localhost”，1883年）；
//mqtt.setHost（“tcp://10.0.0.62", 5445);
mqtt.setHost（sAddress）；
Log.d（标签，“地址集：”+sAddress）；
}捕获（URI语法异常URI）{
Log.e（标记“URISyntaxException连接到”+sAddress+“-”
+乌里斯）；
}
if（sUserName！=null&！sUserName.equals（“”）{
mqtt.setUserName（sUserName）；
Log.d（标记，“用户名集：[“+sUserName+”]”）；
}
if（sPassword！=null&！sPassword.equals（“”）{
mqtt.setPassword（sPassword）；
Log.d（标签，“密码集：[“+sPassword+”]”）；
}
//futureConnection=mqtt.futureConnection（）；
progressDialogListener=ProgressDialog.show（此“”，
“setListener…”，正确）；
progressDialogListener.setCanceledOnTouchOutside（true）；
callBackConnection=mqtt.callBackConnection（）；
callBackConnection.listener（新侦听器（）{
未连接的公共空间（）{
i（标记“callBackconnect（）->setListener:onConnected”）；
//新建AlertDialog.Builder（MQTTActivity.this）
//.setMessage（“已连接（侦听器）”）
//.setNeutralButton（“确定”，null）.show（）；
progressDialogListener.disclose（）；
}
公共空间已断开连接（）{
i（标记“callBackconnect（）->setListener:onDisconnected”）；
//新建AlertDialog.Builder（MQTTActivity.this）
//.setMessage（“已断开连接（侦听器）”）
//.setNeutralButton（“确定”，null）.show（）；
progressDialogListener.disclose（）；
}
失败时公共无效（可丢弃arg0）{
Log.i（标签，
“callBackconnect（）->setListener:onFailure：”
+arg0.toString（））；
Log.e（标记arg0.toString（））；
//新建AlertDialog.Builder（MQTTActivity.this）
//.setMessage（“失败（侦听器）”）
//.setNeutralButton（“确定”，null）.show（）；
progressDialogListener.disclose（）；
}
public void onPublish（UTF8Buffer主题、Buffer msg、Runnable ack）{
Log.i（标签，
“callBackconnect（）->setListener:onPublish（UTF8Buffer arg0，Buffer arg1，Runnable arg2）”；
//新建AlertDialog.Builder（MQTTActivity.this）
//.setMessage（“发布（侦听器）”）
//.setNeutralButton（“确定”，null）.show（）；
最后一个字符串msgBody=msg.utf8（）.toString（）；
最后一个字符串topicBody=topic.utf8（）.toString（）；
//创建可运行的过帐
mHandler.post（新Runnable（）{
公开募捐{
updateReceiveETInUi（主题体，msgBody）；
}
});
Log.i（标签，
callBackconnect（）->setListener:onPublish（UTF8Buffer arg0、缓冲区arg1、可运行arg2）：
+主题体+“：”+msgBody）；
if（msgBody.startsWith（“回复：））{
//不要回复你自己的回复
Log.i（标签，
“callBackconnect（）->setListener:onPublish->msgBody.startsWith REPLY”）；
}否则{
试一试{
byte[]reply=“reply:Hello Back”.getBytes（）；
callBackConnection.publish（目标、回复、，
QoS.AT_最多_次，true，null）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
}
});
//callBackConnection.resume（）；
progressDialogConn=ProgressDialog.show（此“，”正在连接…”，
真的，真的）；
callBackConnection.connect（新回调（）{
失败时公共无效（可丢弃值）{
Log.i（标签，
“callBackconnect（）->connect->.onFailure:”
+value.toString（））；
Log.e（标签，
“callBackconnect（）->connect->.onFailure:”
+value.toString（））；
//新建AlertDialog.Builder（MQTTActivity.this）
//.setMessage（value.toString（））
//.setNeutralButton（“确定”，null）.show（）；
progressDialogConn.discover（）；
}
成功时公开作废（作废v）{
Log.i（标记，“callBackconnect（）->connect->onSuccess（Void v）”
+v.TYPE.toString（））；
//新的
//AlertDialog.Builder（MQTTActivity.this）.setMessage（“已连接（回调）”）
//.setNeutralButton（“确定”，null）.show（）；
progressDialogConn.discover（）；
}
成功时公共无效（UTF8Buffer主题、缓冲区有效负载、可运行确认）{
//您现在可以处理从主题收到的消息。
//一旦进程执行ack
   public void onSuccess(UTF8Buffer topic, Buffer payload, Runnable ack) {