smack 源码分析- PacketReader (android上实现长连接)

http://blog.csdn.net/wqhjfree/article/details/7194428

smack 源码分析- PacketWriter (android上实现长连接) 介绍完PacketWriter 之后, 接下来分析PacketReader. PacketReader的作用主要用来接收云端推送的消息并解析然后调用相应的监听器完成相关的操作.

什么都别说, 先看代码:

[java] view plaincopy

1. //构造函数  
2. protected PacketReader(final XMPPConnection connection) {  
3.         this.connection = connection;  
4.         this.init();  
5. }  
6.   
7.   
8.  /** 
9.      * Initializes the reader in order to be used. The reader is initialized 
10.      * during the first connection and when reconnecting due to an abruptly 
11.      * disconnection. 
12.      */  
13.     protected void init() {  
14.         done = false;  
15.         connectionID = null;  
16.   
17.         //开辟一个线程, 解析收到的数据包  
18.         readerThread = new Thread() {  
19.             public void run() {  
20.                 parsePackets(this);  
21.             }  
22.         };  
23.         readerThread.setName("Smack Packet Reader (" + connection.connectionCounterValue + ")");  
24.         readerThread.setDaemon(true);  
25.   
26.         // Create an executor to deliver incoming packets to listeners. We'll  
27.         // use a single  
28.         // thread with an unbounded queue.  
29.         listenerExecutor = Executors.newSingleThreadExecutor(new ThreadFactory() {  
30.   
31.             public Thread newThread(Runnable runnable) {  
32.                 Thread thread = new Thread(runnable, "Smack Listener Processor ("  
33.                         + connection.connectionCounterValue + ")");  
34.                 thread.setDaemon(true);  
35.                 return thread;  
36.             }  
37.         });  
38.   
39.         resetParser();  
40.     }  
41.   
42.   
43.   
44.   
45.  /** 
46.      * Parse top-level packets in order to process them further. 
47.      *  
48.      * @param thread the thread that is being used by the reader to parse 
49.      *            incoming packets. 
50.      */  
51.     private void parsePackets(Thread thread) {  
52.         try {  
53.             int eventType = parser.getEventType();  
54.             do {  
55.   
56.                 if (eventType == XmlPullParser.START_TAG) {  
57.                     if (parser.getName().equals("message")) {  
58.                         processPacket(PacketParserUtils.parseMessage(parser));  
59.                     } else if (parser.getName().equals("iq")) {  
60.                         processPacket(PacketParserUtils.parseIQ(parser, connection));  
61.                     } else if (parser.getName().equals("presence")) {  
62.                         processPacket(PacketParserUtils.parsePresence(parser));  
63.                     }  

构造函数和init()方法PacketWriter一样, 不多说了. 直接看parsePackets(). 在parsePackets()是直接调用processPacket()方法解析, 我们再来看processPacket()方法:

[java] view plaincopy

1. /** 
2.      * Processes a packet after it's been fully parsed by looping through the 
3.      * installed packet collectors and listeners and letting them examine the 
4.      * packet to see if they are a match with the filter. 
5.      *  
6.      * @param packet the packet to process. 
7.      */  
8.     private void processPacket(Packet packet) {  
9.         if (packet == null) {  
10.             return;  
11.         }  
12.   
13.         // Loop through all collectors and notify the appropriate ones.  
14.         for (PacketCollector collector : connection.getPacketCollectors()) {  
15.             collector.processPacket(packet);  
16.         }  
17.   
18.         // Deliver the incoming packet to listeners.  
19.         listenerExecutor.submit(new ListenerNotification(packet));  
20.     }  

在processPacket()的最后一行是通过ExecutorService类型的一个listenerExecutor实例执行一个线程ListenerNotification完成的. 接下来: 

[java] view plaincopy

1. /** 
2.      * A runnable to notify all listeners of a packet. 
3.      */  
4.     private class ListenerNotification implements Runnable {  
5.   
6.         private Packet packet;  
7.   
8.         public ListenerNotification(Packet packet) {  
9.             this.packet = packet;  
10.         }  
11.   
12.         public void run() {  
13.             //循环读取注册了的监听器并通知处理packet  
14.             for (ListenerWrapper listenerWrapper : connection.recvListeners.values()) {  
15.                   
16.                 listenerWrapper.notifyListener(packet);  
17.             }  
18.         }  
19.     }  

在ListenerNotification的run方法中,  是循环读取connection.recvListeners.values()获取ListenerWrapper .

那么ListenerWrapper 是什么呢? 我们首先来看这里connection.recvListeners.values(), 这connection实际上

是一个XMPPConnection的一个实例, 而XMPPConnection继承了Connection, recvListeners实际上是Connection

的一个成员变量. 然后再来看ListenerWrapper类:

[java] view plaincopy

1. /** 
2.      * A wrapper class to associate a packet filter with a listener. 
3.      * 
4.      */  
5.     protected static class ListenerWrapper {  
6.   
7.         private PacketListener packetListener;  
8.   
9.         private PacketFilter packetFilter;  
10.   
11.         /** 
12.          * Create a class which associates a packet filter with a listener. 
13.          *  
14.          * @param packetListener the packet listener. 
15.          * @param packetFilter the associated filter or null if it listen for 
16.          *            all packets. 
17.          */  
18.         public ListenerWrapper(PacketListener packetListener, PacketFilter packetFilter) {  
19.             this.packetListener = packetListener;  
20.             this.packetFilter = packetFilter;  
21.         }  
22.   
23.         /** 
24.          * Notify and process the packet listener if the filter matches the 
25.          * packet.  
26.          * @param packet the packet which was sent or received. 
27.          */  
28.         public void notifyListener(Packet packet) {  
29.             if (packetFilter == null || packetFilter.accept(packet)) {   
30.                 packetListener.processPacket(packet);  
31.             }  
32.         }  
33.     }  

ListenerWrapper类实际上是一个包装类, 该类的作用是将packetListener 和packetFilter关联在一起. 那么

packetListener 和packetFilter分别是什么嗯, 查看smack帮助文档可知:

Smack提供灵活的框架来通过两种构造处理收到的 packet：

• org.jivesoftware.smack.PacketCollector —— 一个让您同步等待新packet的类。
• org.jivesoftware.smack.PacketListener —— 一个异步通知您引入的packet的接口。

packet监听器用于事件样式的编程，而packet收集器有一个可以做轮询和阻塞操作的packet的结果队列。 所以，当您想对一个有可能随时到来的packet采取一些操作时，使用packet监听器；而当您想等待一个特别的packet到来时，使用packet收集器。您可以使用XMPPConnection实例创建packet收集器和监听器。

PacketFilter 接口决定哪个特别的将会被传递到PacketCollector或PacketListener。filter package包中有许多预定义的过滤器。

packetListener 是一个能够处理随时可能到了的packet监听器,packetFilter能够判断packet是否由该packetListener处理

是的话则调用processPacket()方法处理packet. 至此整个过程处理完成