packetprocessor.java

用java实现的

        AddFriendReplyPacket packet = (AddFriendReplyPacket)in;
        if(packet.replyCode == QQ.QQ_AUTH_NO_AUTH) {
            log.debug("好友添加成功");
            e = new QQEvent(monitor.retrieveRequest(packet));
            e.type = QQEvent.QQ_ADD_FRIEND_SUCCESS;
            this.fireQQEvent(e);
        } else if(packet.replyCode == QQ.QQ_AUTH_NEED_AUTH) {
            log.debug("对方要求认证");
            e = new QQEvent(monitor.retrieveRequest(packet));
            e.type = QQEvent.QQ_ADD_FRIEND_NEED_AUTH;
            this.fireQQEvent(e);
        } else if(packet.replyCode == QQ.QQ_AUTH_NO_ADD) {
            log.debug("对方禁止别人加他为好友");
            e = new QQEvent(monitor.retrieveRequest(packet));
            e.type = QQEvent.QQ_ADD_FRIEND_FORBIDDEN;
            this.fireQQEvent(e);
        }
    }

    // 处理系统消息，比如谁谁谁添加你为好友
    private void processSystemNotification(InPacket in) throws PacketParseException {
        QQEvent e = null;
        SystemNotificationPacket packet = (SystemNotificationPacket)in;
        // 判断类型
        if(packet.type == QQ.QQ_MSG_SYS_BEING_ADDED) {
	        e = new QQEvent(packet);
            e.type = QQEvent.QQ_ADDED_BY_OTHERS;            
        } else if(packet.type == QQ.QQ_MSG_SYS_ADD_FRIEND_REQUEST) {
            e = new QQEvent(packet);
            e.type = QQEvent.QQ_REQUEST_ADD_ME;
        } else if(packet.type == QQ.QQ_MSG_SYS_ADD_FRIEND_APPROVED) {
            e = new QQEvent(packet);
            e.type = QQEvent.QQ_REQUEST_ADD_OTHER_APPROVED;
        } else if(packet.type == QQ.QQ_MSG_SYS_ADD_FRIEND_REJECTED) {
            e = new QQEvent(packet);
            e.type = QQEvent.QQ_REQUEST_ADD_OTHER_REJECTED;
        } else {
        	log.debug("未知类型的系统通知，忽略");
        }
        // 触发事件
        if(e != null)
            this.fireQQEvent(e);
    }

    // 处理未知命令，没有实际操作，简单打印内容
    private void processRequestKeyReply(InPacket in) throws PacketParseException {
        RequestKeyReplyPacket packet = (RequestKeyReplyPacket)in;
        QQEvent e;
        if(packet.replyCode == QQ.QQ_REQUEST_KEY_REPLY_OK) {
	        e = new QQEvent(packet);            
            e.type = QQEvent.QQ_REQUEST_KEY_SUCCESS;
	        this.fireQQEvent(e);
        } else {
	        e = new QQEvent(monitor.retrieveRequest(packet));            
            e.type = QQEvent.QQ_REQUEST_KEY_FAIL;
	        this.fireQQEvent(e);            
        }
    }

    // 处理收到的消息
    private void processReceiveIM(InPacket in) throws PacketParseException {
        QQEvent e;
        ReceiveIMPacket packet = (ReceiveIMPacket)in;
        // 开始处理
        if(packet.header.type == QQ.QQ_RECV_IM_TO_BUDDY || packet.header.type == QQ.QQ_RECV_IM_TO_UNKNOWN) {
            e = new QQEvent(packet);
        	switch(packet.normalHeader.type) {
        		case QQ.QQ_IM_NORMAL_TEXT:
		            log.debug("接收到一条普通消息，消息发送者" + packet.header.sender);
		            log.debug("消息内容: " + packet.normalIM.message);
		            log.debug("消息发送时间: " + new Date(packet.normalHeader.sendTime).toString());
		            e.type = QQEvent.QQ_RECEIVE_NORMAL_IM;
		            break;
		        case QQ.QQ_IM_UDP_REQUEST:
	        		log.debug("对方请求传送文件，协议UDP" + " 传送文件端口：" + packet.fileArgs.directPort);
	        		e.type = QQEvent.QQ_REQUEST_SEND_FILE;
	        		break;
	        	case QQ.QQ_IM_REJECT_UDP_REQUEST:
	            	log.debug("对方拒绝了传送文件的请求");
	            	e.type = QQEvent.QQ_REJECT_SEND_FILE;
	            	break;
	            case QQ.QQ_IM_ACCEPT_UDP_REQUEST:
	            	log.debug("对方接受了传送文件的请求");
	            	e.type = QQEvent.QQ_ACCEPT_SEND_FILE;
	            	break;
	            case QQ.QQ_IM_NOTIFY_IP:
	            	log.debug("对方告诉我文件发送的IP和端口，其外部IP为" + Utils.getIpStringFromBytes(packet.fileArgs.internetIp) +
	            			" 其外部端口为" + packet.fileArgs.internetPort + " 其第一个监听端口为" + packet.fileArgs.directPort +
							" 其真实IP为" + Utils.getIpStringFromBytes(packet.fileArgs.localIp) +
							" 其第二个监听端口为" + packet.fileArgs.localPort);
	            	e.type = QQEvent.QQ_NOTIFY_FILE_TRANSFER_ARGS;
	            	break;
	            case QQ.QQ_IM_PLEASE_CONNECT_ME:
	            	log.debug("对方请求自己主动连接他");
	            	e.type = QQEvent.QQ_REQUEST_ME_CONNECT;
	            	break;
	            case QQ.QQ_IM_REQUEST_CANCELED:
	            	log.debug("对方取消了文件传送");
	            	e.type = QQEvent.QQ_CANCEL_SEND_FILE;
	            	break;
	            default:
	        		log.debug("接受到一条非文本消息，目前无法处理，忽略该消息");
	        		e.type = QQEvent.QQ_UNKNOWN_TYPE_IM;
	        		break;
        	}
        	this.fireQQEvent(e);
        } else if(packet.header.type == QQ.QQ_RECV_IM_SYS_MESSAGE) {
            log.debug("接收到一条系统消息: " + packet.sysMessage);
            if(packet.systemMessageType == QQ.QQ_RECV_IM_KICK_OUT) {
            	log.debug("帐号在其他地方登录，此处被踢出");
            	e = new QQEvent(packet);
            	e.type = QQEvent.QQ_KICKED_OUT_BY_SYSTEM;
            	this.fireQQEvent(e);
            } else {
	            e = new QQEvent(packet);	
	            e.type = QQEvent.QQ_RECEIVE_SYS_MESSAGE;
	            this.fireQQEvent(e);            	
            }
        } else if(packet.header.type == QQ.QQ_RECV_IM_CLUSTER_IM) {
        	log.debug("接收到一条群组消息，消息内容：" + packet.clusterIM.message);
        	e = new QQEvent(packet);
        	e.type = QQEvent.QQ_RECEIVE_CLUSTER_IM;
        	this.fireQQEvent(e);
        } else if(packet.header.type == QQ.QQ_RECV_IM_CREATE_CLUSTER ||
        		packet.header.type == QQ.QQ_RECV_IM_ADDED_TO_CLUSTER) {
        	log.debug("收到一条" + Utils.getIMTypeString(packet.header.type) + "消息");
        	e = new QQEvent(packet);
        	e.type = QQEvent.QQ_I_AM_ADDED_TO_CLUSTER;
        	this.fireQQEvent(e);
        } else if(packet.header.type == QQ.QQ_RECV_IM_DELETED_FROM_CLUSTER) {
        	log.debug("我被创建者从群中删除");
        	e = new QQEvent(packet);
        	e.type = QQEvent.QQ_I_AM_REMOVED_FROM_CLUSTER;
        	this.fireQQEvent(e);
		} else if(packet.header.type == QQ.QQ_RECV_IM_APPROVE_JOIN_CLUSTER) {
			log.debug("对方同意我加入群，附加消息为：" + packet.message);
			e = new QQEvent(packet);
			e.type = QQEvent.QQ_REQUEST_JOIN_CLUSTER_APPROVED;
			this.fireQQEvent(e);
		} else if(packet.header.type == QQ.QQ_RECV_IM_REJECT_JOIN_CLUSTER) {
			log.debug("对方拒绝我加入群，附加消息为：" + packet.message);
			e = new QQEvent(packet);
			e.type = QQEvent.QQ_REQUEST_JOIN_CLUSTER_REJECTED;
			this.fireQQEvent(e);
		} else if(packet.header.type == QQ.QQ_RECV_IM_REQUEST_JOIN_CLUSTER) {
			log.debug("对方请求加入我的群，附加消息为：" + packet.message);
			e = new QQEvent(packet);
			e.type = QQEvent.QQ_REQUEST_JOIN_CLUSTER;
			this.fireQQEvent(e);
        } else {
            log.debug("接收到一条" + Utils.getIMTypeString(packet.header.type) + "消息，目前无法处理，忽略");
        }
    }

    // 处理Keep Alive的回复事件
    private void processKeepAliveReply(InPacket in) throws PacketParseException {
        QQEvent e;
        KeepAliveReplyPacket packet = (KeepAliveReplyPacket)in;
        if(log.isDebugEnabled()) {
            log.debug("Keep Alive: 在线数: " + packet.onlines + "我的IP: " + packet.ip);
        }
        
        // 触发事件
        e = new QQEvent(packet);
        e.type = QQEvent.QQ_KEEP_ALIVE_SUCCESS;
        this.fireQQEvent(e);
    }

    // 处理发送消息回复事件
    private void processSendIMReply(InPacket in) throws PacketParseException {
        QQEvent e;
        SendIMReplyPacket packet = (SendIMReplyPacket)in;
        if(packet.replyCode == QQ.QQ_SEND_IM_REPLY_OK) {
        	SendIMPacket srcPacket = (SendIMPacket)monitor.retrieveRequest(packet);
        	char messageType = srcPacket.getMessageType();
        	if(messageType == QQ.QQ_IM_NORMAL_TEXT) {
	            log.debug("消息发送成功");
	            e = new QQEvent(srcPacket);
	            e.type = QQEvent.QQ_SEND_IM_SUCCESS;
	            this.fireQQEvent(e);        		
        	} else if(messageType == QQ.QQ_IM_UDP_REQUEST) {
        		log.debug("传送文件请求已发送，等待对方接受");
        		e = new QQEvent(srcPacket);
        		e.type = QQEvent.QQ_SEND_FILE_REQUEST_SEND_SUCCESS;
        		this.fireQQEvent(e);
        	} else if(messageType == QQ.QQ_IM_NOTIFY_IP) {
        	    log.debug("IP信息已发送，等待对方返回确认");
        	}
        }
    }

    // 处理得到在线好友回复事件
    private void processGetFriendOnlineReply(InPacket in) throws PacketParseException {
        QQEvent e;
        GetFriendOnlineReplyPacket packet = (GetFriendOnlineReplyPacket)in;
        if(log.isDebugEnabled()) {
            Iterator iter = packet.onlineFriends.iterator();
            while(iter.hasNext()) {
                FriendStatus fs = ((FriendOnlineEntry)iter.next()).status;
                log.debug("好友" + fs.qqNum + "在线状态" + Utils.getStatusString(fs.status));
            }
        }
        
        // 触发事件，如果已经全部得到了，则触发结束事件，如果没有全部得到，则触发成功事件
        if(packet.position == QQ.QQ_FRIEND_ONLINE_LIST_POSITION_END) {
            e = new QQEvent(packet);
            e.type = QQEvent.QQ_GET_FRIEND_ONLINE_END;
            this.fireQQEvent(e);
        } else {
	        e = new QQEvent(packet);
	        e.type = QQEvent.QQ_GET_FRIEND_ONLINE_SUCCESS;
	        this.fireQQEvent(e);            
        }
    }

    // 处理得到好友列表回复事件
    private void processGetFriendListReply(InPacket in) throws PacketParseException {
        QQEvent e;
        GetFriendListReplyPacket packet = (GetFriendListReplyPacket)in;
        /*if(log.isDebugEnabled()) {
            Iterator iter = packet.friends.iterator();
            while(iter.hasNext()) {
                QQFriend friend = (QQFriend)iter.next();
                log.debug("得到好友" + friend.qqNum + ", 昵称: " + friend.nick);
            }
        }*/
        
        // 触发事件，如果已经全部得到，则触发得到列表结束事件，否则只是触发得到列表成功事件
        if(packet.position == QQ.QQ_FRIEND_LIST_POSITION_END) {
            e = new QQEvent(packet);
            e.type = QQEvent.QQ_GET_FRIEND_LIST_END;
            this.fireQQEvent(e);
        } else {
	        e = new QQEvent(packet);
	        e.type = QQEvent.QQ_GET_FRIEND_LIST_SUCCESS;
	        this.fireQQEvent(e);            
        }
    }

    // 处理改变状态回复事件
    private void processChangeStatusReply(InPacket in) throws PacketParseException {
        QQEvent e;
        ChangeStatusReplyPacket packet = (ChangeStatusReplyPacket)in;
        
        // 检查应答码
        if(packet.replyCode == QQ.QQ_CHANGE_STATUS_REPLY_OK) {
            log.debug("改变状态成功");
            e = new QQEvent(packet);
            e.type = QQEvent.QQ_CHANGE_STATUS_SUCCESS;
            this.fireQQEvent(e);
        } else {
        	log.debug("改变状态失败");
            e = new QQEvent(packet);
            e.type = QQEvent.QQ_CHANGE_STATUS_FAIL;
            this.fireQQEvent(e);            
        }
    }
    
    // 处理得到用户信息回复事件 
    private void processGetUserInfoReply(InPacket in) throws PacketParseException {
        QQEvent e;
        GetUserInfoReplyPacket packet = (GetUserInfoReplyPacket)in;
        /*if(log.isDebugEnabled()) {
            for(int i = 0; i < QQ.QQ_CONTACT_FIELDS; i++)
                log.debug("用户信息字段" + i + ": " + packet.contactInfo.infos[i]);
        }*/
        // 触发成功事件
        e = new QQEvent(packet);
        e.type = QQEvent.QQ_GET_USER_INFO_SUCCESS;
        this.fireQQEvent(e);
    }

    // 处理好友状态改变事件
	private void processFriendChangeStatus(InPacket in) throws PacketParseException {
		QQEvent e;
		FriendChangeStatusPacket packet = (FriendChangeStatusPacket)in;
		if(packet.friendStatus.qqNum == 0) {
			log.warn("好友状态改变包中数据有误，忽略该包");
		} else {
			log.debug("好友" + packet.friendStatus.qqNum + "状态改变成" + Utils.getStatusString(packet.friendStatus.status));
			// 触发事件
			e = new QQEvent(packet);
			e.type = QQEvent.QQ_FRIEND_CHANGE_STATUS;
			this.fireQQEvent(e);
		}
	}

	/* (non-Javadoc)
     * @see edu.tsinghua.lumaqq.protocol.qq.PacketListener#packetSent(edu.tsinghua.lumaqq.protocol.qq.PacketEvent)
     */
    public void packetSent(PacketEvent e) {
    }
    
    /**
     * 添加一个QQ事件监听器
     * @param listener QQListener
     */
    public void addQQListener(QQListener listener) {
    	qqListeners.add(listener);
    	setListenerChanged(true);
    }
    
    /**
     * 移去一个QQ事件监听器
     * @param listener QQListener
     */
    public void removeQQListener(QQListener listener) {
    	qqListeners.remove(listener);
    	setListenerChanged(true);
    }
    
    /**
     * 清楚所有监听器
     */
    public void removeAllQQListener() {
    	qqListeners.clear();
    	setListenerChanged(true);
    }
    
    /**
     * 触发QQ事件
     * @param e QQEvent
     */
    public void fireQQEvent(QQEvent e) {
    	checkListenerChange();
    	Iterator iter = qqListenersBackup.iterator();
    	while(iter.hasNext())
    		((QQListener)iter.next()).qqEvent(e);
    }
    
    // 设置listener changed标志
    private synchronized void setListenerChanged(boolean b) {
    	listenerChanged = b;
    }
    
    // 得到listener changed标志
    private synchronized boolean isListenerChanged() {
    	return listenerChanged;
    }
    
    // 检查监听器是否已经改变，如果是则更新监听器
    private synchronized void checkListenerChange() {
    	if(isListenerChanged()) {
    		qqListenersBackup.clear();
    		Iterator iter = qqListeners.iterator();
    		while(iter.hasNext())
    			qqListenersBackup.add(iter.next());
    		setListenerChanged(false);
    	}
    }
}