Android Quickblox：仅接收正确的消息

我正在使用quickblox开发聊天工具，但在打开新聊天工具时遇到了一些问题。当我断开连接时，我突然收到了其他用户发送给我的所有消息。问题是，当我开始与用户a聊天时，我会收到来自用户B、C、D的聊天。。在聊天室里

我找到了只显示A用户的方法。但问题是服务器已经向我发送了“断开连接”的消息，因此当我开始与B聊天时，我没有收到任何文本，因为用户B发送给我的消息已在我与用户a聊天时发送（并省略）

我该如何接收挂起的消息（历史记录）或仅检索我登录的聊天的消息

我的一段代码：

private MessageListener messageListener = new MessageListener() {

    @Override
    public void processMessage(Chat chat, Message message) {

        System.out.println("CridaC");

         String from = message.getFrom().split("@")[0];
            String to = message.getTo().split("@")[0];

            System.out.println(String.format(">>> Message received (from=%s, to=%s): %s",from, to, message.getBody()));

//              return;

        if (onMessageReceivedListener != null && message.getBody() != null) {
            System.out.println("CridaD");

            onMessageReceivedListener.onMessageReceived(message);
        }
    }
};

---

有人知道我如何在几个步骤中部署聊天吗？

这是一种正常的行为。登录后，您将收到来自所有用户的所有消息。无论您现在是否与用户A聊天

可能的解决方案-将所有新消息存储到ArrayList HashMap中。

---

当您打开与用户B的聊天时，只需从此ArrayList/HashMap检索来自用户B的消息，并将其显示在屏幕上

您需要获取此特定用户的聊天对话框，以便获取其历史记录。 实际上，当两个用户第一次开始聊天时，会为他们创建一个对话框来执行聊天。他们将始终在此对话框下聊天。对话可以说是一种聊天的平台。Dialog还有一个对话框id。Quickblox提供了一个函数，可以代表您想要聊天的friendID创建对话框（您需要将friendID传递到此函数）。如果这是第一次聊天，此功能将为您创建一个dialogId，如果您之前执行过聊天，则会返回现有的dialogId。获取此dialogID后，您可以借助此dialogID获取聊天历史记录

结论：您只能通过dialogID获取聊天历史记录

代码如下：

1.）创建chatManager对象

2.）使用QuickBlox QBChatMessage对象创建自定义邮件对象：

public class ChatMessageModel {
    private Integer id;
    private String body;
    private Collection<Integer> readIds;
    private Integer recipientId;
    private String nameToDisplayOnlyWhenAMessageIsReceived;
    private String messageId;
    private Integer senderId;
    private String message;
    private String dialogId;
    private long time;
    private boolean isMessageSelected=false; //true if user selects an item or copy or delete and vice versa

    public boolean isMessageSelected() {
        return isMessageSelected;
    }

    public void setIsMessageSelected(boolean isMessageSelected) {
        this.isMessageSelected = isMessageSelected;
    }

    public String getMessageId() {
        return messageId;
    }
    public void setMessageId(String messageId) {
        this.messageId = messageId;
    }

    public Integer getSenderId() {
        return senderId;
    }

    public void setSenderId(Integer senderId) {
        this.senderId = senderId;
    }


    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getId() {
        return id;
    }

    public String getBody() {
        return body;
    }

    public String getNameToDisplayOnlyWhenAMessageIsReceived() {
        return nameToDisplayOnlyWhenAMessageIsReceived;
    }

    public void setNameToDisplayOnlyWhenAMessageIsReceived(String nameToDisplayOnlyWhenAMessageIsReceived) {
        this.nameToDisplayOnlyWhenAMessageIsReceived = nameToDisplayOnlyWhenAMessageIsReceived;
    }


    public void setBody(String body) {
        this.body = body;
    }

//    public Collection<Integer> getReadIds() {
//        return readIds;
//    }

    public void setReadIds(Collection<Integer> readIds) {
        this.readIds = readIds;
    }

    public Integer getRecipientId() {
        return recipientId;
    }

    public void setRecipientId(Integer recipientId) {
        this.recipientId = recipientId;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public String getDialogId() {
        return dialogId;
    }

    public void setDialogId(String dialogId) {
        this.dialogId = dialogId;
    }

    public void setTime(long time) {
        this.time = time;
    }

    public Long getTime() {
        return time;
    }

    @Override
    public boolean equals(Object obj) {
    //    return super.equals(o);
        if (obj == null || obj.getClass() != ChatMessageModel.class) {
            return false;
        }
        ChatMessageModel other = (ChatMessageModel) obj;
        if (other.messageId != this.messageId) {
            return false;
        }

        return true;
    }

    @Override
    public int hashCode() {
    //    return super.hashCode();
        return messageId == null ? 0 : messageId.hashCode();
    }

    @Override
    public String toString() {
        return messageId;
    }
}

公共类ChatMessageModel{
私有整数id；
私有字符串体；
私人收藏ReadID；
私有整数recipientId；
接收到名称消息时显示的私有字符串名称；
私有字符串messageId；
私有整数senderId；
私有字符串消息；
私有字符串dialogId；
私人时间长；
私有布尔值isMessageSelected=false；//如果用户选择项目或复制或删除，则为true，反之亦然
公共布尔isMessageSelected（）{
返回已选择的消息；
}
public void集合isMessageSelected（布尔isMessageSelected）{
this.isMessageSelected=isMessageSelected；
}
公共字符串getMessageId（）{
返回messageId；
}
public void setMessageId（字符串messageId）{
this.messageId=messageId；
}
公共整数getSenderId（）{
返回senderId；
}
public void setSenderId（整数senderId）{
this.senderId=senderId；
}
公共无效集合id（整数id）{
this.id=id；
}
公共整数getId（）{
返回id；
}
公共字符串getBody（）{
返回体；
}
公共字符串getnametodisplaynlywhenamessageisreceived（）{
将收到的姓名返回到DisplayOnly；
}
已接收公共void SetNameToDisplaynlyWhenNamesAgiesReceived（字符串名称ToDisplaynlyWhenNamesAgiesReceived）{
this.nametodisplaynlywhenamessageisreceived=nametodisplaynlywhenamessageisreceived；
}
公共体（字符串体）{
这个身体=身体；
}
//公共集合getReadId（）{
//返回readid；
//    }
public void setreadid（集合readid）{
this.readIds=readIds；
}
公共整数getRecipientId（）{
返回接收方ID；
}
public void setRecipientId（整数recipientId）{
this.recipientId=recipientId；
}
公共无效设置消息（字符串消息）{
this.message=消息；
}
公共字符串getMessage（）{
返回消息；
}
公共字符串getDialogId（）{
返回对话框ID；
}
public void setDialogId（字符串dialogId）{
this.dialogId=dialogId；
}
公共无效设置时间（长时间）{
这个时间=时间；
}
公共长getTime（）{
返回时间；
}
@凌驾
公共布尔等于（对象obj）{
//返回super.equals（o）；
if（obj==null | | obj.getClass（）！=ChatMessageModel.class）{
返回false；
}
ChatMessageModel other=（ChatMessageModel）obj；
if（other.messageId！=此.messageId）{
返回false；
}
返回true；
}
@凌驾
公共int hashCode（）{
//返回super.hashCode（）；
return messageId==null？0:messageId.hashCode（）；
}
@凌驾
公共字符串toString（）{
返回messageId；
}
}

3.）获取聊天记录的功能：

public void getChatHistoryForDialog(Integer otherUserId, final Integer numberOfMessages) {

        final ArrayList<ChatMessageModel> myList = new ArrayList<ChatMessageModel>();

        privateChatManager.createDialog(otherUserId, new QBEntityCallbackImpl<QBDialog>() {
            @Override
            public void onSuccess(final QBDialog dialog, Bundle args) {
                QBRequestGetBuilder requestBuilder = new QBRequestGetBuilder();
                requestBuilder.sortAsc("last_message_date_sent");
                requestBuilder.setPagesLimit(numberOfMessages.intValue());// limit of max messages fetch from server
                QBChatService.getDialogMessages(dialog, requestBuilder, new QBEntityCallbackImpl<ArrayList<QBChatMessage>>() {
                    @Override
                    public void onSuccess(ArrayList<QBChatMessage> messages, Bundle args) {
                        for (QBChatMessage message : messages) {
                            ChatMessageModel model = new ChatMessageModel();
                            model.setIsMessageSelected(false);
                            model.setId(message.getSenderId());
                            model.setMessageId(message.getId());
                            model.setMessage(message.getBody());
                            message.setMarkable(true);
                            model.setTime(message.getDateSent() * 1000L);// Multiplied by 1000L because the time given by Quickblox server is epoch time
                            model.setReadIds(message.getReadIds());
                            model.setRecipientId(message.getRecipientId());
                            model.setDialogId(dialog.getDialogId());
                            myList.add(model);
                        }

                    }

                    @Override
                    public void onError(List<String> errors) {
                    }
                });
            }

            @Override
            public void onError(List<String> errors) {
            }
        });

    }

public void getChatHistoryForDialog（整数otherUserId，最终整数numberOfMessages）{
最终ArrayList myList=新ArrayList（）；
createDialog（otherUserId，新的QBEntityCallbackImpl（）{
@凌驾
成功时公共无效（最终QB对话框，捆绑参数）{
QBRequestGetBuilder requestBuilder=新的QBRequestGetBuilder（）；
sortAsc（“上次发送的消息日期”）；
requestBuilder.setPagesLimit（numberOfMessages.intValue（））；//从服务器获取的最大消息数限制
getDialogMessages（对话框，requestBuilder，新的QBEntityCallbackImpl（）{
@凌驾
成功时公共无效（ArrayList消息、捆绑参数）{
用于（QBChatMessage消息：消息）{
中国