Android学习笔记--基于XMPP的即时通讯

本是古典 何须时尚 2021-06-26 16:06 711阅读 0赞

一、常见即时通讯实现

socket

openfire+asmack

环信

信鸽

融云

二、XMPP优势

1. 开放性

XMPP协议是自由、开放、公开的，并且易于了解。而且在客户端、服务器、组件、源码库等方面，都已经各自有多种实现。

2.跨平台

客户端只要基于XMPP协议，不管是什么平台（包括不同的移动终端）都可以互联互通。

三、XMPP协议简介

The Extensible Messaging and Presence Protocol (可扩展通讯和表示协议) XMPP 以 Jabber 协议为基础，而 Jabber 是即时通讯中常用的开放式协议。

四、数据格式

XML是XMPP系统架构的核心。它能表述几乎任何一种结构化数据。特别是XMPP利用XML数据流进行客户端一服务器端、服务器端一服务器端的通信。XML数据流一般是由客户端发起至服务端，XML数据流的有效时间直接与用户的在线会话有效时间相关联。

XMPP 的特点是将复杂性从客户端转移到服务器端。这使得客户端编写变得非常容易，更新系统功能也同样变得容易。

XMPP中定义了三个角色：XMPP客户端、XMPP服务器、网关。

客户端：通过 TCP 套接字与XMPP 服务器进行通信

服务器：同时承担了客户端信息记录、连接管理和信息的路由功能

网关：承担着与异构即时通信系统的互联互通（异构系统可以包括SMS（短信），MSN，ICQ等）

五、XMPP协议的地址格式（标志）

每个客户端需要拥有一个地址标识用于定位，XMPP 中称之为 JID (Jabber ID)。地址标识的格式如下

  1. [ node "@" ] domain [ "/" resource ]

例如：

  1. charley@gmail.com/spark

格式与 Email 地址格式类似，但增添了 resource 项（非必需的）。上述例子可以解释为：在 gmail.com 服务器注册的 charley用户，且使用 spark客户端软件登录。资源（resource ）只用来识别属于用户的位置或设备等，一个用户可以同时以多种资源与同一个XMPP服务器连接（说白了就是用于支持同一账号的多客户端登录）。

六、协议消息格式

XMPP协议包括3个顶层XML元素：Message、Presence和IQ。

Message用来表示传输的消息，当用户发送一条消息时。就会在流的上下文中插入一个Message元素，中间有用户发送的相关信息；

Presence用来表示用户的状态。当用户改变自己的状态时。就会在数据流的上下文中插入一个Presence元素，用来表示用户现在的状态；

IQ用来表示一种请求，响应机制，从一个实体发送请求，另外一个实体接受请求并响应。

XMPP特点

1.客户端通过TCP/IP协议连接到服务器，然后通过XML传输数据。

2.XMPP的核心部分就是一个在网络上分片断发送XML的流协议。这个流协议是XMPP的即时通讯指令的传递基础，也是一个非常重要的可以被进一步利用的网络基础协议。所以可以说，XMPP用TCP传的是XML流。

理论一大堆。。。。接下来贴代码

XmppManager.java

  1. package com.example.xmppdemo.fengzhuang;
  3.  import android.util.Log;
  7.  import org.jivesoftware.smack.Chat;
  8.  import org.jivesoftware.smack.ChatManager;
  9.  import org.jivesoftware.smack.ChatManagerListener;
  10.  import org.jivesoftware.smack.ConnectionConfiguration;
  11.  import org.jivesoftware.smack.MessageListener;
  12.  import org.jivesoftware.smack.PacketCollector;
  13.  import org.jivesoftware.smack.Roster;
  14.  import org.jivesoftware.smack.RosterEntry;
  15.  import org.jivesoftware.smack.SmackConfiguration;
  16.  import org.jivesoftware.smack.XMPPConnection;
  17.  import org.jivesoftware.smack.XMPPException;
  18.  import org.jivesoftware.smack.filter.AndFilter;
  19.  import org.jivesoftware.smack.filter.PacketFilter;
  20.  import org.jivesoftware.smack.filter.PacketIDFilter;
  21.  import org.jivesoftware.smack.filter.PacketTypeFilter;
  22.  import org.jivesoftware.smack.packet.IQ;
  23.  import org.jivesoftware.smack.packet.Message;
  24.  import org.jivesoftware.smack.packet.Presence;
  25.  import org.jivesoftware.smack.packet.Registration;
  26.  import org.jivesoftware.smack.provider.PrivacyProvider;
  27.  import org.jivesoftware.smack.provider.ProviderManager;
  28.  import org.jivesoftware.smackx.Form;
  29.  import org.jivesoftware.smackx.GroupChatInvitation;
  30.  import org.jivesoftware.smackx.PrivateDataManager;
  31.  import org.jivesoftware.smackx.ReportedData;
  32.  import org.jivesoftware.smackx.bytestreams.socks5.provider.BytestreamsProvider;
  33.  import org.jivesoftware.smackx.packet.ChatStateExtension;
  34.  import org.jivesoftware.smackx.packet.LastActivity;
  35.  import org.jivesoftware.smackx.packet.OfflineMessageInfo;
  36.  import org.jivesoftware.smackx.packet.OfflineMessageRequest;
  37.  import org.jivesoftware.smackx.packet.SharedGroupsInfo;
  38.  import org.jivesoftware.smackx.packet.VCard;
  39.  import org.jivesoftware.smackx.provider.AdHocCommandDataProvider;
  40.  import org.jivesoftware.smackx.provider.DataFormProvider;
  41.  import org.jivesoftware.smackx.provider.DelayInformationProvider;
  42.  import org.jivesoftware.smackx.provider.DiscoverInfoProvider;
  43.  import org.jivesoftware.smackx.provider.DiscoverItemsProvider;
  44.  import org.jivesoftware.smackx.provider.MUCAdminProvider;
  45.  import org.jivesoftware.smackx.provider.MUCOwnerProvider;
  46.  import org.jivesoftware.smackx.provider.MUCUserProvider;
  47.  import org.jivesoftware.smackx.provider.MessageEventProvider;
  48.  import org.jivesoftware.smackx.provider.MultipleAddressesProvider;
  49.  import org.jivesoftware.smackx.provider.RosterExchangeProvider;
  50.  import org.jivesoftware.smackx.provider.StreamInitiationProvider;
  51.  import org.jivesoftware.smackx.provider.VCardProvider;
  52.  import org.jivesoftware.smackx.provider.XHTMLExtensionProvider;
  53.  import org.jivesoftware.smackx.search.UserSearch;
  54.  import org.jivesoftware.smackx.search.UserSearchManager;
  56.  import java.util.ArrayList;
  57.  import java.util.Collection;
  58.  import java.util.Collections;
  59.  import java.util.Iterator;
  60.  import java.util.List;
  62.  /** * Created by Kelvin on 2016/12/12. */
  64.  public class XmppManager { 
  66.      private static XmppManager xmppManager; //XmppManager的实例
  68.      private XmppManager(){ } //私有化构造器
  70.      public static XmppManager getInstance(){ 
  71.          if (xmppManager == null){ 
  72.              synchronized (XmppManager.class){ 
  73.                  if (xmppManager == null){ 
  74.                      xmppManager = new XmppManager();
  75.                  }
  76.              }
  77.          }
  78.          return xmppManager;
  79.      }
  81.      //XmppConnection 连接对象
  82.      private XMPPConnection xmppConnection;
  84.      //将其翻译成中文为"花名册"，用来表示一个用户的所有好友清单以及申请加好友的用户清单，
  85.      // 为了便于管理，Roster中的用户分组进行管理。
  86.      private Roster roster;
  88.      //用于接收消息的接口
  89.      private XmppManagerCallback xmppManagerCallback;
  91.      //Debug标签
  92.      private final String TAG="XmppManager";
  94.      /** * 打开网络连接 */
  95.      private void openConnection(){ 
  97.          //连接对象为空或者还没有认证的时候(isAuthenticated()方法返回值是boolean类型,意思是是否认证)
  98.          if (xmppConnection == null || !xmppConnection.isAuthenticated()){ 
  99.              try { 
  100.                  //配置连接,(参数一:服务器ip地址,参数二:端口号,参数三:服务器名字)
  101.                  ConnectionConfiguration configuration = new ConnectionConfiguration(Constant.SERVER_HOST,
  102.                          Constant.SERVER_PORT,Constant.SERVER_NAME);
  104.                  //Xmpp是否可以自动重连(客户端掉线时是否可以重新连接)
  105.                  configuration.setReconnectionAllowed(true);
  107.                  //设置安全模式
  108.                  configuration.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);
  109.                  //特别补充，在设置configuaration的时候对认证的设置，代码如下：
  110.                  //这个属性默认值是true，设置时得需要与服务器那边统一，如果不一致，就算用户注册成功后，
  111.                  // 登录时也会返回 server-unavailable(503)错误，我们用的是ejabberd服务器，默认设置SASL认证开启，
  112.                  // 所以开始我设置为false，怎么都无法登录，最后注释这句代码，成功登录：）
  113.                  //相当于一个权限
  114.                  configuration.setSASLAuthenticationEnabled(false);
  115.                  // 状态设为离线，为了取离线消息
  116.                  configuration.setSendPresence(true);
  117.                  // 配置各种Provider，如果不配置，则会无法解析数据
  118.                  configureConnection(ProviderManager.getInstance());
  119.                  xmppConnection = new XMPPConnection(configuration);
  120.                  //打开连接
  121.                  xmppConnection.connect();
  122.              } catch (XMPPException e) { 
  123.                  e.printStackTrace();
  124.              }
  125.          }
  126.      }
  128.      /** * 配置连接 * @param pm */
  129.      public void configureConnection(ProviderManager pm) { 
  130.          // Private Data Storage
  131.          pm.addIQProvider("query", "jabber:iq:private", new PrivateDataManager.PrivateDataIQProvider());
  132.          // Time
  133.          try { 
  134.              pm.addIQProvider("query", "jabber:iq:time", Class.forName("org.jivesoftware.smackx.packet.Time"));
  135.          } catch (ClassNotFoundException e) { 
  136.              Log.w("TestClient", "Can't load class for org.jivesoftware.smackx.packet.Time");
  137.          }
  139.          // Roster Exchange
  140.          pm.addExtensionProvider("x", "jabber:x:roster", new RosterExchangeProvider());
  141.          // Message Events
  142.          pm.addExtensionProvider("x", "jabber:x:event", new MessageEventProvider());
  143.          // Chat State
  144.          pm.addExtensionProvider("active", "http://jabber.org/protocol/chatstates", new ChatStateExtension.Provider());
  145.          pm.addExtensionProvider("composing", "http://jabber.org/protocol/chatstates", new ChatStateExtension.Provider());
  146.          pm.addExtensionProvider("paused", "http://jabber.org/protocol/chatstates", new ChatStateExtension.Provider());
  147.          pm.addExtensionProvider("inactive", "http://jabber.org/protocol/chatstates", new ChatStateExtension.Provider());
  148.          pm.addExtensionProvider("gone", "http://jabber.org/protocol/chatstates", new ChatStateExtension.Provider());
  149.          // XHTML
  150.          pm.addExtensionProvider("html", "http://jabber.org/protocol/xhtml-im", new XHTMLExtensionProvider());
  151.          // Group Chat Invitations
  152.          pm.addExtensionProvider("x", "jabber:x:conference", new GroupChatInvitation.Provider());
  153.          // Service Discovery # Items
  154.          pm.addIQProvider("query", "http://jabber.org/protocol/disco#items", new DiscoverItemsProvider());
  155.          // Service Discovery # Info
  156.          pm.addIQProvider("query", "http://jabber.org/protocol/disco#info", new DiscoverInfoProvider());
  157.          // Data Forms
  158.          pm.addExtensionProvider("x", "jabber:x:data", new DataFormProvider());
  159.          // MUC User
  160.          pm.addExtensionProvider("x", "http://jabber.org/protocol/muc#user", new MUCUserProvider());
  161.          // MUC Admin
  162.          pm.addIQProvider("query", "http://jabber.org/protocol/muc#admin", new MUCAdminProvider());
  163.          // MUC Owner
  164.          pm.addIQProvider("query", "http://jabber.org/protocol/muc#owner", new MUCOwnerProvider());
  165.          // Delayed Delivery
  166.          pm.addExtensionProvider("x", "jabber:x:delay", new DelayInformationProvider());
  167.          // Version
  168.          try { 
  169.              pm.addIQProvider("query", "jabber:iq:version", Class.forName("org.jivesoftware.smackx.packet.Version"));
  170.          } catch (ClassNotFoundException e) { 
  171.              // Not sure what's happening here.
  172.          }
  173.          // VCard
  174.          pm.addIQProvider("vCard", "vcard-temp", new VCardProvider());
  175.          // Offline Message Requests
  176.          pm.addIQProvider("offline", "http://jabber.org/protocol/offline", new OfflineMessageRequest.Provider());
  177.          // Offline Message Indicator
  178.          pm.addExtensionProvider("offline", "http://jabber.org/protocol/offline", new OfflineMessageInfo.Provider());
  179.          // Last Activity
  180.          pm.addIQProvider("query", "jabber:iq:last", new LastActivity.Provider());
  181.          // User Search
  182.          pm.addIQProvider("query", "jabber:iq:search", new UserSearch.Provider());
  183.          // SharedGroupsInfo
  184.          pm.addIQProvider("sharedgroup", "http://www.jivesoftware.org/protocol/sharedgroup",
  185.                  new SharedGroupsInfo.Provider());
  186.          // JEP-33: Extended Stanza Addressing
  187.          pm.addExtensionProvider("addresses", "http://jabber.org/protocol/address", new MultipleAddressesProvider());
  188.          // FileTransfer
  189.          pm.addIQProvider("si", "http://jabber.org/protocol/si", new StreamInitiationProvider());
  190.          pm.addIQProvider("query", "http://jabber.org/protocol/bytestreams", new BytestreamsProvider());
  191.          // Privacy
  192.          pm.addIQProvider("query", "jabber:iq:privacy", new PrivacyProvider());
  193.          pm.addIQProvider("command", "http://jabber.org/protocol/commands", new AdHocCommandDataProvider());
  194.          pm.addExtensionProvider("malformed-action", "http://jabber.org/protocol/commands",
  195.                  new AdHocCommandDataProvider.MalformedActionError());
  196.          pm.addExtensionProvider("bad-locale", "http://jabber.org/protocol/commands",
  197.                  new AdHocCommandDataProvider.BadLocaleError());
  198.          pm.addExtensionProvider("bad-payload", "http://jabber.org/protocol/commands",
  199.                  new AdHocCommandDataProvider.BadPayloadError());
  200.          pm.addExtensionProvider("bad-sessionid", "http://jabber.org/protocol/commands",
  201.                  new AdHocCommandDataProvider.BadSessionIDError());
  202.          pm.addExtensionProvider("session-expired", "http://jabber.org/protocol/commands",
  203.                  new AdHocCommandDataProvider.SessionExpiredError());
  204.      }
  206.      /** * 获取链接 * @return */
  207.      public XMPPConnection getConnection(){ 
  208.          if (xmppConnection == null){ 
  209.              openConnection();
  210.          }
  211.          return  xmppConnection;
  212.      }
  214.      /** * 关闭链接 */
  215.      public void colseConnection(){ 
  216.          if (xmppConnection != null && xmppConnection.isConnected()){ 
  217.              xmppConnection.disconnect();
  218.              xmppConnection = null;
  219.          }
  220.      }
  222.      /** * 登陆的方法 * @param account 账号 * @param psw 密码 * @return */
  223.      public boolean login(String account,String psw){ 
  225.          //判断连接是否存在
  226.          if (getConnection() == null){ 
  227.              return false;
  228.          }
  230.          if (!getConnection().isAuthenticated() && getConnection().isConnected()){ 
  231.              try { 
  232.                  //登陆
  233.                  getConnection().login(account,psw);
  234.                  //登陆之后更改用户状态
  235.                  Presence presence = new Presence(Presence.Type.available);
  236.                  //设置用户在线
  237.                  presence.setMode(Presence.Mode.available);
  238.                  //向服务器发送状态
  239.                  getConnection().sendPacket(presence);
  240.                  //接收消息监听
  241.                  ChatManager chatManager = getConnection().getChatManager();
  242.                  chatManager.addChatListener(chatManagerListener);
  243.                  return true;
  244.              } catch (XMPPException e) { 
  245.                  e.printStackTrace();
  246.                  return false;
  247.              }
  248.          }
  249.          return false;
  250.      }
  252.      /** * 聊天管理监听器 */
  253.      private ChatManagerListener chatManagerListener = new ChatManagerListener(){ 
  255.          @Override
  256.          public void chatCreated(Chat chat, boolean b) { 
  257.              chat.addMessageListener(new MessageListener() { 
  258.                  @Override
  259.                  public void processMessage(Chat chat, Message message) { 
  260.                      //当消息内容为空时,直接反悔
  261.                      if (TVUtil.isEmpty(message.getBody())){ 
  262.                          return;
  263.                      }
  264.                      //当消息内容不可空时,通过接口回调的把消息内容传出去
  265.                      if (xmppManagerCallback != null){ 
  266.                          xmppManagerCallback.receiveMsg(message);
  267.                      }
  268.                  }
  269.              });
  270.          }
  271.      };
  273.      /** * 注册用户 * 表示的是Info/Query(信息与查询)，它为XMPP通信提供请求与响应机制。它与HTTP * 协议的基本工作原理非常相似，允许获取和设置查询，与HTTP 的GET 和POST 动作类似。 * @return */
  274.      public IQ registered(String account, String psw){ 
  276.          if (getConnection() == null){ 
  277.              return null;
  278.          }
  280.          //设置注册所需要的信息
  281.          Registration registration = new Registration();
  282.          registration.setType(IQ.Type.SET);
  283.          registration.setTo(getConnection().getServiceName());
  284.          registration.setUsername(account);
  285.          registration.setPassword(psw);
  287.          //PacketFilter:包过滤类,过滤一些不用的包
  288.          PacketFilter filter = new AndFilter(new PacketIDFilter(registration.getPacketID()), new PacketTypeFilter(IQ.class));
  289.          PacketCollector collector = getConnection().createPacketCollector(filter);
  290.          // 向服务器端，发送注册Packet包，注意其中Registration是Packet的子类
  291.          getConnection().sendPacket(registration);
  292.          IQ result = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
  293.          collector.cancel(); //停止请求result
  294.          return result;
  295.      }
  297.      /** * 退出登陆 */
  298.      public void outLogin(){ 
  299.          if (getConnection() == null){ 
  300.              return;
  301.          }
  303.          //设置退出状态
  304.          Presence presence = new Presence(Presence.Type.unavailable);
  305.          //发送请求
  306.          getConnection().sendPacket(presence);
  307.          //关闭连接
  308.          colseConnection();
  309.      }
  311.      /** * 获取用户信息 * @param user * @return */
  312.      public VCard getUserInfo(String user){ 
  313.          VCard vCard = null;
  314.          try { 
  315.              vCard = new VCard();
  316.              // 加入这句代码，解决No VCard for
  317.              ProviderManager.getInstance().addIQProvider("vCard", "vcard-temp", new VCardProvider());
  318.              if (user == null){ 
  319.                  vCard.load(getConnection());
  320.              }else{ 
  321.                  vCard.load(getConnection(), user + "@" + Constant.SERVER_NAME);
  322.              }
  323.          } catch (XMPPException e) { 
  324.              e.printStackTrace();
  325.          }
  326.          return vCard;
  327.      }
  329.      /** * 获取xmpp好友列表 * 注意:这里的User是在Xmpp包下的User */
  330.      public List<User> getFriendList() { 
  331.          // Roster:花名册
  332.          if (roster == null) { 
  333.              roster = getConnection().getRoster();
  334.          }
  335.          List<User> userList = new ArrayList<User>();
  336.          Collection<RosterEntry> entries = roster.getEntries();
  337.          for(RosterEntry entry : entries){ 
  338.              userList.add(new User(getUsername(entry.getUser()),entry.getType()));
  339.          }
  340.          Collections.sort(userList,new PingyinComparator());
  341.          return userList;
  342.      }
  344.      /** * 通过jid获得username * @param fullUsername * @return */
  345.      public static String getUsername(String fullUsername){ 
  346.          return fullUsername.split("@")[0];
  347.      }
  349.      /** * 搜索用户 * @param userName * @return * @throws XMPPException */
  350.      public List<String> searchUser(String userName) { 
  351.          if (getConnection() == null){ 
  352.              return null;
  353.          }
  354.          List<String> userList = new ArrayList<>();
  355.          try { 
  356.              UserSearchManager search = new UserSearchManager(getConnection());
  357.              Form searchForm = search.getSearchForm("search."+ getConnection().getServiceName());
  358.              Form answerForm = searchForm.createAnswerForm();
  359.              answerForm.setAnswer("Username", true);
  360.              answerForm.setAnswer("search", userName.trim());
  361.              ReportedData data = search.getSearchResults(answerForm,"search." + xmppConnection.getServiceName());
  362.              Iterator<ReportedData.Row> it = data.getRows();
  363.              ReportedData.Row row = null;
  364.              while (it.hasNext()) { 
  365.                  row = it.next();
  366.                  userList.add(row.getValues("Username").next().toString());
  367.              }
  368.          } catch (XMPPException e) { 
  369.              e.printStackTrace();
  370.          }
  371.          return userList;
  372.      }
  374.      /** * 添加好友(无分组) * @param userName * @return */
  375.      public boolean addFriend(String userName) { 
  376.          if (getConnection() == null)
  377.              return false;
  378.          try { 
  379.              getConnection().getRoster().createEntry(getFullUsername(userName), getFullUsername(userName), null);
  380.              return true;
  381.          } catch (Exception e) { 
  382.              e.printStackTrace();
  383.              return false;
  384.          }
  385.      }
  387.      /** * 通过username获得jid * @param username * @return */
  388.      public static String getFullUsername(String username){ 
  389.          return username + "@" + Constant.SERVER_NAME;
  390.      }
  392.      /** * 创建聊天 * @param toUser * @return */
  393.      public Chat createChat(String toUser){ 
  394.          ChatManager chatManager = getConnection().getChatManager();
  395.          Chat newchat = chatManager.createChat(toUser + "@"+ Constant.SERVER_NAME, null);
  396.          return newchat;
  397.      }
  399.      /** * 发送文本消息 * @param message */
  400.      public void sendMsg(Chat chat, String message) { 
  401.          try { 
  402.              chat.sendMessage(message);
  403.          } catch (Exception e) { 
  404.              e.printStackTrace();
  405.          }
  406.      }
  408.      /** * 接口回调 */
  409.      public interface XmppManagerCallback { 
  410.          //接收消息回调函数
  411.          void receiveMsg(Message message);
  412.      }
  414.      /** * 设置接口的方法 * @param xmppManagerCallback 接口对象 */
  415.      public void setXmppManagerCallback(XmppManagerCallback xmppManagerCallback) { 
  416.          this.xmppManagerCallback = xmppManagerCallback;
  417.      }
  418.  }

这里面封装了所有的方法

ChatMsg.java

  1. package com.example.xmppdemo.fengzhuang;
  2.  import android.os.Parcel;
  3.  import android.os.Parcelable;
  5.  /** * * 描述(请用一句话描述这个内容) */
  7.  public class ChatMsg implements Parcelable { 
  9.      private String sender; // 发送者
  10.      private String body; // 发送的消息
  12.      public String getSender() { 
  13.          return sender;
  14.      }
  16.      public void setSender(String sender) { 
  17.          this.sender = sender;
  18.      }
  20.      public String getBody() { 
  21.          return body;
  22.      }
  24.      public void setBody(String body) { 
  25.          this.body = body;
  26.      }
  28.      public static final Creator<ChatMsg> CREATOR = new Creator<ChatMsg>() { 
  29.          @Override
  30.          public ChatMsg createFromParcel(Parcel in) { 
  31.              ChatMsg chatMsg = new ChatMsg();
  32.              chatMsg.sender = in.readString();
  33.              chatMsg.body = in.readString();
  34.              return chatMsg;
  35.          }
  37.          @Override
  38.          public ChatMsg[] newArray(int size) { 
  39.              return null;
  40.          }
  41.      };
  43.      @Override
  44.      public int describeContents() { 
  45.          return 0;
  46.      }
  48.      @Override
  49.      public void writeToParcel(Parcel parcel, int i) { 
  50.          parcel.writeString(sender);
  51.          parcel.writeString(body);
  52.      }
  53.  }

还有一个

ChatService.java

  1. package com.example.xmppdemo.service;
  3. import android.app.Activity;
  4. import android.app.Notification;
  5. import android.app.NotificationManager;
  6. import android.app.PendingIntent;
  7. import android.app.Service;
  8. import android.content.BroadcastReceiver;
  9. import android.content.Context;
  10. import android.content.Intent;
  11. import android.content.IntentFilter;
  12. import android.os.IBinder;
  13. import android.support.annotation.Nullable;
  16. import com.example.xmppdemo.ChatActivity;
  17. import com.example.xmppdemo.R;
  18. import com.example.xmppdemo.fengzhuang.ChatMsg;
  19. import com.example.xmppdemo.fengzhuang.Constant;
  20. import com.example.xmppdemo.fengzhuang.XmppManager;
  22. import org.jivesoftware.smack.XMPPException;
  23. import org.jivesoftware.smack.packet.Message;
  24. import org.jivesoftware.smackx.OfflineMessageManager;
  26. import java.util.ArrayList;
  27. import java.util.Iterator;
  29. /** 31 * 描述(请用一句话描述这个内容) */
  30. public class ChatService extends Service implements XmppManager.XmppManagerCallback { 
  32.     //接收到的消息集合，包括两种消息: 1，不在对话框界面的消息 2，离线消息
  33.     private ArrayList<ChatMsg> messageList = new ArrayList<>();
  34.     private MesageBroadcastReceiver mesageReceiver;
  36.     @Override
  37.     public void onCreate() { 
  38.         XmppManager.getInstance().setXmppManagerCallback(this);
  39.         //注册消息接收广播
  40.         IntentFilter filter = new IntentFilter(Constant.INTENT_ACTION_MESSAGE_RECEIVE);
  41.         mesageReceiver = new MesageBroadcastReceiver();
  42.         registerReceiver(mesageReceiver, filter);
  43.     }
  45.     @Nullable
  46.     @Override
  47.     public IBinder onBind(Intent intent) { 
  48.         return null;
  49.     }
  51.     @Override
  52.     public void receiveMsg(Message message) { 
  53.         ChatMsg chatMsg = new ChatMsg();
  55.         chatMsg.setSender(message.getFrom());
  56.         chatMsg.setBody(message.getBody());
  57.         sendReceiverMsgBroadCast(chatMsg);
  58.     }
  59.     /** * 发送广播的方法 * @param */
  60.     private void sendReceiverMsgBroadCast(ChatMsg chatMsg){ 
  61.         Intent intent = new Intent();
  62.         intent.setAction(Constant.INTENT_ACTION_MESSAGE_RECEIVE);
  63.         intent.putExtra("message", chatMsg);
  64.         /** * MesageBroadcastReceiver指定为最后的接受者，Activity.RESULT_CANCELED指定初始的结果码， * 如果ChatActivity中的广播接收者处理了这条广播，则结果码会在ChatActivity中被更改为Activity.RESULT_OK， * 反之，ChatActivity中的广播接收者没有处理，则结果码仍然为Activity.RESULT_CANCELED */
  65.         sendOrderedBroadcast(intent,null,mesageReceiver,null, Activity.RESULT_CANCELED,null,null);
  66.     }
  67.     /** * 消息广播 */
  68.     private class MesageBroadcastReceiver extends BroadcastReceiver{ 
  70.         @Override
  71.         public void onReceive(Context context, Intent intent) { 
  72.             ChatMsg chatMsg = intent.getParcelableExtra("message");
  73.             int resultCode = getResultCode();
  74.             if (isOrderedBroadcast()){   //判断是否有下一个广播,true为是 false为无
  76.                 if (resultCode != Activity.RESULT_OK){ 
  77.                     showMsgNotice(chatMsg);
  78.                 }
  79.             }
  80.         }
  81.     }
  83.     /** * 显示消息通知 * @param chatMsg 消息类 */
  84.     private void showMsgNotice(ChatMsg chatMsg){ 
  85.         messageList.add(chatMsg);  //把消息实体加入到集合中
  86.         //获取通知服务
  87.         NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
  88.         //取消所有
  89.         nm.cancelAll();
  90.         //创建消息
  91.        /* Notification notification = new Notification(R.drawable.ic_launcher ,"您有"+messageList.size()+"条新消息", System.currentTimeMillis()); notification.flags = Notification.FLAG_AUTO_CANCEL; notification.sound= Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.ms); Intent intent = new Intent(this, ChatActivity.class); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK); intent.putExtra("from", "notification"); intent.putParcelableArrayListExtra("messageList", messageList); PendingIntent contentIntent = PendingIntent.getActivity(this, R.string.app_name, intent, PendingIntent.FLAG_UPDATE_CURRENT); notification.setLatestEventInfo(this, chatMsg.getSender().split("@")[0], chatMsg.getBody(), contentIntent); nm.notify(0, notification);*/
  93.         Notification.Builder builder = new Notification.Builder(this);
  94.         builder.setContentText("微信通知"); //设置通知的标题
  95.         builder.setSmallIcon(R.drawable.search_icon); //设置通知的小图标
  96.         builder.setContentText("您有"+messageList.size()+"条新消息"); //写入通知内容
  97. // builder.setSound(Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.ms));
  98.         Intent intent = new Intent(this, ChatActivity.class);
  99.         intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
  100.         intent.putExtra("from", "notification");
  101.         intent.putParcelableArrayListExtra("messageList", messageList);
  102.         PendingIntent contentIntent = PendingIntent.getActivity(this, R.string.app_name, intent, PendingIntent.FLAG_UPDATE_CURRENT);
  103.         builder.setContentIntent(contentIntent);
  104.         //获得通知
  105.         Notification notification = builder.getNotification();
  106.         nm.notify(0, notification);
  107.     }
  109.     /** * 获取离线消息 */
  110.     public void getOfflineMessage() { 
  111.         OfflineMessageManager offlineMessageManager = new OfflineMessageManager(XmppManager.getInstance().getConnection());
  112.         try { 
  113.             Iterator<Message> it = offlineMessageManager.getMessages();
  114.             while (it.hasNext()) { 
  115.                 Message message = it.next();
  116.                 ChatMsg chatMsg = new ChatMsg();
  117.                 chatMsg.setSender(message.getFrom());
  118.                 chatMsg.setBody(message.getBody());
  119.                 sendReceiverMsgBroadCast(chatMsg);
  120.             }
  121.             offlineMessageManager.deleteMessages();
  122.         } catch (XMPPException e) { 
  123.             e.printStackTrace();
  124.         }
  125.     }
  127.     @Override
  128.     public void onDestroy() { 
  129.         super.onDestroy();
  130.         XmppManager.getInstance().colseConnection();
  131.         unregisterReceiver(mesageReceiver);
  132.     }
  133. }

基本重要的就这么多，代码附上，

链接：http://pan.baidu.com/s/1hs1Dg3M 密码：s57b

可能说的不是很清楚，但是代码里面都有

能看到的代码不是自己的，自己写出来的才是自己的

发表评论

表情：
评论列表 （有 0 条评论，711人围观）

还没有评论，来说两句吧...

相关阅读