Openfire 单人聊天和多人聊天（发送消息、接收消息）

Openfire 单人聊天和多人聊天（发送消息、接收消息）

一、单人聊天

1）发送消息：

首先要获取一个聊天窗口，getConnection()为获取连接connection的方法，调用getFriendChat()获取

  1. private Map<String, Chat> chatManage = new HashMap<String, Chat>();// 聊天窗口管理map集合
  2.  
  3. /**
  4. * 获取或创建聊天窗口
  5. * @param friend 好友名
  6. * @param listenter 聊天監聽器
  7. * @return
  8. */
  9. public Chat getFriendChat(String friend, MessageListener listenter) {
  10. if(getConnection()==null)
  11. return null;
  12. /** 判断是否创建聊天窗口 */
  13. for (String fristr : chatManage.keySet()) {
  14. if (fristr.equals(friend)) {
  15. // 存在聊天窗口，则返回对应聊天窗口
  16. return chatManage.get(fristr);
  17. }
  18. }
  19. /** 创建聊天窗口 */
  20. Chat chat = getConnection().getChatManager().createChat(friend + "@"+
  21. getConnection().getServiceName(), listenter);
  22. /** 添加聊天窗口到chatManage */
  23. chatManage.put(friend, chat);
  24. return chat;
  25. }

 

friend为好友名，不是JID；listener 监听器可以传null，利用聊天窗口对象调用sendMessage发送消息

这里sendMessage我传的是一个JSON字符串，以便更灵活的控制，发送消息完成，很简单吧~

  1. Chat chat = getFriendChat(friend,null);
  2. try {
  3. String msgjson = "{\"messageType\":\""+messageType+"\",\"chanId\":\""+chanId+"\",\"chanName\":\""+chanName+"\"}";
  4. chat.sendMessage(msgjson);
  5. } catch (XMPPException e) {
  6. e.printStackTrace();
  7. }


2）接受消息：

创建一个消息监听器，这里我单独写了一个类

  1. package com.techrare.listener;
  2.  
  3. import org.jivesoftware.smack.Chat;
  4. import org.jivesoftware.smack.ChatManagerListener;
  5. import org.jivesoftware.smack.MessageListener;
  6. import org.jivesoftware.smack.packet.Message;
  7. import org.jivesoftware.smack.util.StringUtils;
  8. import org.json.JSONException;
  9. import org.json.JSONObject;
  10.  
  11. import com.techrare.utils.XmppConnection;
  12.  
  13. /**
  14. * 单人聊天信息监听类
  15. *
  16. * @author Administrator
  17. *
  18. */
  19. public class TaxiChatManagerListener implements ChatManagerListener {
  20.  
  21. public void chatCreated(Chat chat, boolean arg1) {
  22. chat.addMessageListener(new MessageListener() {
  23. public void processMessage(Chat arg0, Message msg) {
  24. //登录用户
  25. StringUtils.parseName(XmppConnection.getInstance().getConnection().getUser());
  26. //发送消息用户
  27. msg.getFrom();
  28. //消息内容
  29. String body = msg.getBody();
  30. boolean left = body.substring(0, 1).equals("{");
  31. boolean right = body.substring(body.length()-1, body.length()).equals("}");
  32. if(left&&right){
  33. try {
  34. JSONObject obj = new JSONObject(body);
  35. String type = obj.getString("messageType");
  36. String chanId = obj.getString("chanId");
  37. String chanName = obj.getString("chanName");
  38. } catch (JSONException e) {
  39. e.printStackTrace();
  40. }
  41.  
  42. }
  43. }
  44. });
  45. }
  46. }


添加监听，最好是放在登录方法中，在关闭连接方法中，移除监听，原因是为了避免重复添加监听，接受重复消息

退出程序应该关闭连接，移除监听，该监听可以接受所有好友的消息，很方便吧~

  1. TaxiChatManagerListener chatManagerListener = new TaxiChatManagerListener();
  2. getConnection().getChatManager().addChatListener(chatManagerListener);
connection.getChatManager().removeChatListener(chatManagerListener);



二、多人聊天（会议室）

1）、发送消息

首先要获取会议室对象（MultiUserChat），有两种方法获取

两个方法前面都有讲到，这里再回顾一下

1、创建会议室  

  1. /**
  2. * 创建房间
  3. *
  4. * @param roomName 房间名称
  5. */
  6. public MultiUserChat createRoom(String user, String roomName,String password) {
  7. if (getConnection() == null)
  8. return null;
  9.  
  10. MultiUserChat muc = null;
  11. try {
  12. // 创建一个MultiUserChat
  13. muc = new MultiUserChat(getConnection(), roomName + "@conference."
  14. + getConnection().getServiceName());
  15. // 创建聊天室
  16. muc.create(roomName);
  17. // 获得聊天室的配置表单
  18. Form form = muc.getConfigurationForm();
  19. // 根据原始表单创建一个要提交的新表单。
  20. Form submitForm = form.createAnswerForm();
  21. // 向要提交的表单添加默认答复
  22. for (Iterator<FormField> fields = form.getFields(); fields
  23. .hasNext();) {
  24. FormField field = (FormField) fields.next();
  25. if (!FormField.TYPE_HIDDEN.equals(field.getType())
  26. && field.getVariable() != null) {
  27. // 设置默认值作为答复
  28. submitForm.setDefaultAnswer(field.getVariable());
  29. }
  30. }
  31. // 设置聊天室的新拥有者
  32. List<String> owners = new ArrayList<String>();
  33. owners.add(getConnection().getUser());// 用户JID
  34. submitForm.setAnswer("muc#roomconfig_roomowners", owners);
  35. // 设置聊天室是持久聊天室，即将要被保存下来
  36. submitForm.setAnswer("muc#roomconfig_persistentroom", true);
  37. // 房间仅对成员开放
  38. submitForm.setAnswer("muc#roomconfig_membersonly", false);
  39. // 允许占有者邀请其他人
  40. submitForm.setAnswer("muc#roomconfig_allowinvites", true);
  41. if (!password.equals("")) {
  42. // 进入是否需要密码
  43. submitForm.setAnswer("muc#roomconfig_passwordprotectedroom",
  44. true);
  45. // 设置进入密码
  46. submitForm.setAnswer("muc#roomconfig_roomsecret", password);
  47. }
  48. // 能够发现占有者真实 JID 的角色
  49. // submitForm.setAnswer("muc#roomconfig_whois", "anyone");
  50. // 登录房间对话
  51. submitForm.setAnswer("muc#roomconfig_enablelogging", true);
  52. // 仅允许注册的昵称登录
  53. submitForm.setAnswer("x-muc#roomconfig_reservednick", true);
  54. // 允许使用者修改昵称
  55. submitForm.setAnswer("x-muc#roomconfig_canchangenick", false);
  56. // 允许用户注册房间
  57. submitForm.setAnswer("x-muc#roomconfig_registration", false);
  58. // 发送已完成的表单（有默认值）到服务器来配置聊天室
  59. muc.sendConfigurationForm(submitForm);
  60. } catch (XMPPException e) {
  61. e.printStackTrace();
  62. return null;
  63. }
  64. return muc;
  65. }

2、加入会议室，

  1. /**
  2. * 加入会议室
  3. *
  4. * @param user
  5. * 昵称
  6. * @param password
  7. * 会议室密码
  8. * @param roomsName
  9. * 会议室名
  10. */
  11. public MultiUserChat joinMultiUserChat(String user, String roomsName,
  12. String password) {
  13. if (getConnection() == null)
  14. return null;
  15. try {
  16. // 使用XMPPConnection创建一个MultiUserChat窗口
  17. MultiUserChat muc = new MultiUserChat(getConnection(), roomsName
  18. + "@conference." + getConnection().getServiceName());
  19. // 聊天室服务将会决定要接受的历史记录数量
  20. DiscussionHistory history = new DiscussionHistory();
  21. history.setMaxChars(0);
  22. // history.setSince(new Date());
  23. // 用户加入聊天室
  24. muc.join(user, password, history,
  25. SmackConfiguration.getPacketReplyTimeout());
  26. Log.i("MultiUserChat", "会议室【"+roomsName+"】加入成功........");
  27. return muc;
  28. } catch (XMPPException e) {
  29. e.printStackTrace();
  30. Log.i("MultiUserChat", "会议室【"+roomsName+"】加入失败........");
  31. return null;
  32. }
  33. }


调用这个两个方法都可以获取到MultiUserChat，根据需求选择一个就可以。

利用MultiUserChat对象调用sendMessage()方法即可，很容易吧~

  1. try {
  2. multiUserChat.sendMessage(message);
  3. } catch (XMPPException e) {
  4. e.printStackTrace();
  5. }

 

2）接受消息

    创建会议室消息监听器，这里我也单独写了一个类

  1. package com.techrare.listener;
  2.  
  3. import org.jivesoftware.smack.PacketListener;
  4. import org.jivesoftware.smack.packet.Message;
  5. import org.jivesoftware.smack.packet.Packet;
  6.  
  7. /**
  8. * 会议室消息监听类
  9. *
  10. * @author Administrator
  11. *
  12. */
  13. public class TaxiMultiListener implements PacketListener {
  14.  
  15. @Override
  16. public void processPacket(Packet packet) {
  17. Message message = (Message) packet;
  18. String body = message.getBody();
  19.  
  20. }
  21. }


添加监听器，每个会议室聊天对象都要添加一个消息监听器,为了避免重复监听

应该把会议室聊天对象放在一个集合当中，需要用到的时候取出来用即可。

multiUserChat.addMessageListener(new TaxiMultiListener());

https://blog.csdn.net/qq_17169057/article/details/50437925

posted @ 2018-12-11 16:53  甜菜波波  阅读(1506)  评论(0)  编辑  收藏  举报