lumaQQ移植到Android之消息篇

版权说明：本文是基于开源LumaQQ下，开发者不直接参与QQ协议的分析工作，移植到Android平台纯粹是为了方便学习和研究之用，并且没有产生任何直接的经济效益，并且纯粹是个人的技术学习研究行为，与本人所在单位没有任何关系。此文的读者在使用过程产生的效益和涉及的法律责任与本人没有直接关系。如果影响到您或您的公司利益，敬请谅解并且与我联系，本人会第一时间作出处理。

作为一个IM工具，如果没有发送、接收消息的功能岂不是搞笑？今天我们就开始进入LumaQQ的核心部分，消息的发送和接收。其中发送部分很简单，前面的文章有过介绍，今天主要就消息的接收部分来做详细的说明。

       QQ的消息大致分为普通消息、群消息、系统消息和临时消息。普通消息就是QQ用户发给你的消息；群消息就是群中的聊天消息；系统消息就是腾讯发给你的一些系统通知；临时消息就是用户创建的临时会话信息。这么多种消息我们如何来管理呢？在这里我们来模拟操作系统的消息处理机制，实现一个消息队列MessageQueue，这个消息队列类大致如下：

1. public class MessageQueue {
2.     // 总队列
3.     private Queue<InPacket> queue;
4.     // 系统消息队列
5.     private Queue<InPacket> sysQueue;
6.     // 延迟处理队列
7.     private Queue<InPacket> postponeQueue;
8.     // 用户消息队列映射哈希表
9.     private Map<Integer, Queue<InPacket>> userQueueMap; 
10.     // 用户临时会话消息映射哈希表
11.     private Map<Integer, Queue<InPacket>> tempSessionQueueMap;
12.     // 短消息队列
13.     private Queue<InPacket> smsQueue;
14.     
15.     // true表示收到的消息应该延迟处理
16.     private boolean postpone;
17.     
18.     public MessageQueue() {
19.     }
20.     
21.     /**
22.      * 清空所有数据
23.      */
24.     public void clear() {
25.     }
26.     
27.     /**
28.      * 添加一个短消息到队列末尾
29.      * 
30.      * @param in
31.      *      要添加的消息包对象
32.      */
33.     public void putSMS(InPacket in) {
34.     }
35.     
36.     /**
37.      * 得到队列中第一条短消息，并且把它从队列中删除
38.      * 
39.      * @return 
40.      *      InPacket，如果队列为空，返回null
41.      */
42.     public InPacket getSMS() {      
43.     }
44.     
45.     /**
46.      * 得到下一条手机短信
47.      * 
48.      * @param qq
49.      * @return
50.      */
51.     public InPacket getSMS(int qq) {        
52.     }
53.     
54.     /**
55.      * 得到下一条手机短信
56.      * 
57.      * @param mobile
58.      * @return
59.      */
60.     public InPacket getSMS(String mobile) {     
61.     }
63.     /**
64.      * 把一个普通消息包推入消息队列
65.      * @param packet 
66.      *      消息包对象
67.      */
68.     public void putMessage(BasicInPacket packet) {
69.     }
70.     
71.     /**
72.      * @param packet 
73.      *      消息包对象
74.      * @param global
75.      *      true表示添加这个消息到总队列中。推到总队列中的效果是这条消息会在tray中
76.      *      闪烁。有时候消息是不需要在tray中闪烁的，比如把群消息设为只显示计数，不显示
77.      *      提示时。
78.      */
79.     public void putMessage(InPacket packet, boolean global) {       
80.     }
81.     
82.     /**
83.      * 把临时会话消息推入队列
84.      * 
85.      * @param packet
86.      */
87.     protected void putTempSessionMessage(ReceiveIMPacket packet) {      
88.     }
90.     /**
91.      * 把一个系统消息推入队列
92.      * @param packet
93.      */
94.     public void putSystemMessage(BasicInPacket packet) {        
95.     }
97.     /**
98.      * 得到一条普通消息，并把他从队列中删除
99.      * 
100.      * @param qq 
101.      *      发送消息的好友QQ号
102.      * @return 
103.      *      如果有消息在返回消息，否则返回null
104.      */
105.     public InPacket getMessage(int qq) {
106.     }
107.     
108.     /**
109.      * 得到一条普通消息，不把他从队列中删除
110.      * 
111.      * @param qq 
112.      *      发送消息的好友QQ号
113.      * @return 
114.      *      如果有消息在返回消息，否则返回null
115.      */
116.     public InPacket peekMessage(int qq) {       
117.     }
118.     
119.     /**
120.      * 把qq号指定的好友或者群的所有消息删除
121.      * 
122.      * @param qq 
123.      *      可能是好友的QQ号，也可能是群的内部ID
124.      */
125.     public void removeMessage(int qq) {     
126.     }
127.     
128.     /**
129.      * 得到一条普通消息，这条消息是该组内队列的第一条
130.      * 
131.      * @param g 
132.      *      Group
133.      * @return 
134.      *      如果有则返回消息，否则返回null
135.      */
136.     public InPacket getGroupMessage(Group g) {      
137.     }
139.     /**
140.      * 得到系统消息队列的第一个包，但是不删除它
141.      * 
142.      * @return
143.      *      系统消息包对象
144.      */
145.     public InPacket peekSystemMessage() {
146.     }
147.     
148.     /**
149.      * 得到一条系统消息，并把他从队列删除
150.      * 
151.      * @return 
152.      *      如果有消息，返回消息，否则返回null
153.      */
154.     public InPacket getSystemMessage() {        
155.     }
157.     /**
158.      * 检查是否某个好友还有消息未读
159.      * 
160.      * @param qqNum
161.      *      好友QQ号
162.      * @return 
163.      *      true如果有消息未读
164.      */
165.     public boolean hasMessage(int qqNum) {
166.     }
167.     
168.     /**
169.      * 检查是否有某个用户的临时会话消息
170.      * 
171.      * @param qqNum
172.      *      QQ号
173.      * @return
174.      *      true表示有临时会话消息未读
175.      */
176.     public boolean hasTempSessionMessage(int qqNum) {
177.     }
178.     
179.     /**
180.      * 得到下一条临时会话消息
181.      * 
182.      * @param qqNum
183.      * @return
184.      */
185.     public InPacket getTempSessionMessage(int qqNum) {
186.     }
187.     
188.     /**
189.      * 得到下一条临时会话消息，不从队列中删除
190.      * 
191.      * @param qqNum
192.      * @return
193.      */
194.     public InPacket peekTempSessionMessage(int qqNum) {
195.     }
196.     
197.     /**
198.      * 检查是否某个群下面有讨论组的消息，如果父群id是0，则检查
199.      * 是否有多人对话消息
200.      * 
201.      * @param parentClusterId
202.      *      父群id，0表示多人对话容器
203.      * @return
204.      *      子群id，如果为-1表示没有子群有消息
205.      */
206.     public int hasSubClusterIM(int parentClusterId) {
207.     }
208.     
209.     /**
210.      * 检查某个组是否有消息未读
211.      * 
212.      * @param g 
213.      *      Group
214.      * @return 
215.      *      true如果有消息未读
216.      */
217.     public boolean hasGroupMessage(Group g) {
218.     }
220.     /**
221.      * @return 
222.      *      true如果还有任何消息未读
223.      */
224.     public boolean hasNext() {
225.     }
227.     /**
228.      * @return 
229.      *      true如果还有系统消息未读
230.      */
231.     public boolean hasSystemMessage() {
232.     }
233.     
234.     /**
235.      * @return 
236.      *      true如果还有短消息
237.      */
238.     public boolean hasSMS() {
239.     }
240.     
241.     /**
242.      * 好友的下一条消息是不是临时会话消息
243.      * 
244.      * @param qq
245.      * @return
246.      */
247.     public boolean isNextTempSessionMessage(int qq) {   
248.     }
250.     /**
251.      * @return 
252.      *      下一条消息的发送者的QQ号，如果是0，表示是系统消息，-1表示
253.      *      无消息如果是群消息，返回的将是群的内部ID
254.      */
255.     public int nextSender() {       
256.     }
257.     
258.     /**
259.      * 返回下一个消息的来源，对于普通消息，返回QQ_IM_FROM_FRIEND，对于
260.      * 系统消息，返回QQ_IM_FROM_SYS，对于群消息，有两种情况，因为群消息
261.      * 包含了普通消息和通知消息，对于普通消息，我们返回QQ_IM_FROM_CLUSTER，
262.      * 对于通知消息，我们返回QQ_IM_FROM_SYS
263.      * 
264.      * @return
265.      *      消息来源标识常量
266.      */
267.     public int nextMessageSource() {        
268.     }
269.     
270.     /**
271.      * 返回该组内下一条消息发送者的QQ号
272.      * 
273.      * @param g
274.      *      Group
275.      * @return
276.      *      QQ号，如果没有消息，返回-1
277.      */
278.     public int nextGroupSender(Group g) {
279.     }
280.     
281.     /**
282.      * @return
283.      *      下一个应该闪烁的消息的发送者
284.      */
285.     public int nextBlinkableIMSender() {
286.     }
287.     
288.     /**
289.      * @return
290.      *      下一条群消息的群号，-1表示没有
291.      */
292.     public int nextClusterIMSender() {
293.     }
294.     
295.     /**
296.      * 一个消息在好友列表还没得到之前到达了，延迟处理这个消息
297.      * 
298.      * @param packet 
299.      *      消息包
300.      */
301.     public void postponeMessage(InPacket packet) {
302.     }
303.     
304.     /**
305.      * 返回下一个延迟处理的消息
306.      * 
307.      * @return 
308.      *      如果有则返回消息，没有返回null
309.      */
310.     public InPacket getPostponedMessage() {
311.     }
313.     /**
314.      * @return Returns the postpone.
315.      */
316.     public synchronized boolean isPostpone() {
317.     }
319.     /**
320.      * @param postpone The postpone to set.
321.      */
322.     public synchronized void setPostpone(boolean postpone) {
323.     }
324. }

有了这个消息队列，我们就可以随时来处理QQ的消息，不会因为没来及读取消息导致消息的丢失。

  QQ消息如此之多只是有个管理的队列显然不够，我们还需要对这些消息进行处理，我们来实现一个处理消息的辅助类MessageHelper，大致代码如下，里面我们现在只处理了普通消息

1. public class MessageHelper {
2.     private MainShell main;
3.     // 分片缓冲，有的长消息会变成几个分片发送，需要保存起来等待所有分片完成
4.     // key是消息id，value是个Object数组，保存了消息的分片
5.     private Map<Integer, Object[]> fragmentCache;
7.     public MessageHelper(MainShell main) {
8.         this.main = main;
9.         fragmentCache = new HashMap<Integer, Object[]>();
10.     }
12.     /**
13.      * 把字节数组转换为String，它为我们处理缺省表情的问题
14.      * 
15.      * @param b
16.      *            消息字节数组
17.      * @return String
18.      */
19.     public String convertBytes(byte[] b) {
20.         StringBuffer sb = new StringBuffer();
21.         int offset = 0;
22.         int length = 0;
23.         for (int i = 0; i < b.length; i++) {
24.             if (b[i] == QQ.QQ_TAG_DEFAULT_FACE) {
25.                 sb.append(Util.getString(b, offset, length));
26.                 sb.append((char) b[i]).append((char) (b[i + 1] & 0xFF));
27.                 i++;
28.                 offset = i + 1;
29.                 length = 0;
30.             } else
31.                 length++;
32.         }
33.         if (length > 0)
34.             sb.append(Util.getString(b, offset, length));
35.         return sb.toString();
36.     }
38.     /**
39.      * 检查这个消息是完整消息还是分片
40.      * 
41.      * @return true表示这个消息是分片消息
42.      */
43.     private boolean isFragment(NormalIM im) {
44.         return im.totalFragments > 1;
45.     }
47.     /**
48.      * 检查这个消息是完整消息还是分片
49.      * 
50.      * @return true表示这个消息是分片消息
51.      */
52.     private boolean isFragment(ClusterIM im) {
53.         return im.fragmentCount > 1;
54.     }
56.     /**
57.      * 添加一个普通消息分片
58.      * 
59.      * @param im
60.      */
61.     private void addFragment(NormalIM im) {
62.         Object[] fragments = fragmentCache.get(im.messageId);
63.         if (fragments == null || fragments.length != im.totalFragments) {
64.             fragments = new Object[im.totalFragments];
65.             fragmentCache.put(im.messageId, fragments);
66.         }
67.         fragments[im.fragmentSequence] = im;
68.     }
70.     /**
71.      * 添加一个群消息分片
72.      * 
73.      * @param im
74.      */
75.     private void addFragment(ClusterIM im) {
76.         Object[] fragments = fragmentCache.get(im.messageId);
77.         if (fragments == null || fragments.length != im.fragmentCount) {
78.             fragments = new Object[im.fragmentCount];
79.             fragmentCache.put(im.messageId, fragments);
80.         }
81.         fragments[im.fragmentSequence] = im;
82.     }
84.     /**
85.      * 得到完整的消息，同时把这个消息从分片缓冲中清楚。调用此方法前，必须先用 isMessageComplete()判断分片是否都已经收到
86.      * 
87.      * @param messageId
88.      *            消息id
89.      * @return ClusterIM对象
90.      */
91.     private ClusterIM getIntegratedClusterIM(int messageId) {
92.         Object[] fragments = fragmentCache.remove(messageId);
93.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
94.         for (Object f : fragments) {
95.             try {
96.                 baos.write(((ClusterIM) f).messageBytes);
97.             } catch (IOException e) {
98.             }
99.         }
100.         ClusterIM ret = (ClusterIM) fragments[fragments.length - 1];
101.         ret.messageBytes = baos.toByteArray();
102.         ret.message = convertBytes(ret.messageBytes);
103.         return ret;
104.     }
106.     /**
107.      * 得到完整的普通消息
108.      * 
109.      * @param messageId
110.      *            消息ID
111.      * @return NormalIM对象
112.      */
113.     private NormalIM getIntegratedNormalIM(int messageId) {
114.         Object[] fragments = fragmentCache.remove(messageId);
115.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
116.         for (Object f : fragments) {
117.             try {
118.                 baos.write(((NormalIM) f).messageBytes);
119.             } catch (IOException e) {
120.             }
121.         }
122.         NormalIM ret = (NormalIM) fragments[0];
123.         ret.message = NormalIMFormalizer.deformalize(baos.toByteArray());
124.         return ret;
125.     }
127.     /**
128.      * 检查是否一个长消息的分片都已经收到了
129.      * 
130.      * @param messageId
131.      *            消息id
132.      * @return true表示已经收到
133.      */
134.     private boolean isMessageComplete(int messageId) {
135.         if (!fragmentCache.containsKey(messageId))
136.             return false;
138.         Object[] fragments = fragmentCache.get(messageId);
139.         for (Object f : fragments) {
140.             if (f == null)
141.                 return false;
142.         }
143.         return true;
144.     }
146.     /**
147.      * 推入一条消息，这个方法会检查是否好友列表已经 得到，如果没有，推入延迟队列
148.      * 
149.      * @param packet
150.      *            消息包
151.      */
152.     public void putNormalIM(ReceiveIMPacket packet) {
153.         // 如果现在是延迟处理
154.         MessageQueue mq = main.getMessageQueue();
155.         if (mq.isPostpone()) {
156.             mq.postponeMessage(packet);
157.             return;
158.         }
160.         // 如果这个消息是分片消息，如果这个消息已经完成，则继续处理，否则推入分片缓冲
161.         if (isFragment(packet.normalIM)) {
162.             addFragment(packet.normalIM);
163.             if (isMessageComplete(packet.normalIM.messageId)) {
164.                 packet.normalIM = getIntegratedNormalIM(packet.normalIM.messageId);
165.             } else {
166.                 return;
167.             }
168.         } else {
169.             packet.normalIM.message = NormalIMFormalizer
170.                     .deformalize(packet.normalIM.messageBytes);
171.         }
173.         // 得到好友在model中的位置，但是有可能为null，因为也许这是用户的第一次登陆
174.         // 其好友列表还没得到，但是这时候有消息来了，对于
175.         // 这种情况，需要特殊处理一下，基本的方法是把消息推入延迟处理队列
176.         User f = ModelRegistry.getUser(packet.normalHeader.sender);
177.         boolean iAmHisStranger = packet.header.type == QQ.QQ_RECV_IM_STRANGER;
178.         boolean noSuchUser = f == null || f.group.isCluster();
179.         // boolean heIsMyStranger = noSuchUser || f.group.isStranger();
180.         boolean heIsMyBlacklist = f != null && f.group.isBlackList();
181.         if (heIsMyBlacklist || noSuchUser && iAmHisStranger) {
182.             return;
183.         }
184.         // if (heIsMyStranger) return;
185.         UIHelper uihelper = main.getUIHelper();
186.         // 如果不存在这个用户，添加到陌生人
187.         if (noSuchUser) {
188.             f = new User();
189.             f.qq = packet.normalHeader.sender;
190.             f.nick = String.valueOf(f.qq);
191.             f.displayName = f.nick;
192.             uihelper.addUser(f, GroupType.STRANGER_GROUP);
193.             main.getUIHelper().refreshGroup();
194.             main.getClient().user_GetInfo(f.qq);
195.         }
196.         uihelper.appendMessage(f, packet.normalIM, packet.normalHeader);
197.         // 推入队列
198.         mq.putMessage(packet);
199.     }
200. }
201. 
     

 

有了这两个基础的类之后我们就可以对QQ消息事件进行处理了。QQ消息方面的事件很多，这里我们只处理一下普通消息的事件

1. protected void OnQQEvent(QQEvent e) {
2.     switch (e.type) {
3.         case QQEvent.IM_RECEIVED:
4.         processReceiveNormalIM(e);
5.         break;
6.     }
7. }
8. /**
9. * 处理收到消息事件
10. * 
11. * @param e
12. *       QQEvent
13. */
14. private void processReceiveNormalIM(QQEvent e) {
15.     // 得到包，推入消息队列
16.     ReceiveIMPacket packet = (ReceiveIMPacket)e.getSource();
17.     main.getMessageHelper().putNormalIM(packet);
18. }

 

代码在这里，请点击下载http://download.csdn.net/source/698372