messagequeue.java

lumaQQ的源文件

	 * 		如果有消息，返回消息，否则返回null
	 */
	public InPacket getSystemMessage() {
		InPacket ret = sysQueue.poll();
		queue.remove(ret);
		return ret;
	}

	/**
	 * 检查是否某个好友还有消息未读
	 * 
	 * @param qqNum
	 * 		好友QQ号
	 * @return 
	 * 		true如果有消息未读
	 */
	public boolean hasMessage(int qqNum) {
		return userQueueMap.containsKey(qqNum);
	}
	
	/**
	 * 检查是否有某个用户的临时会话消息
	 * 
	 * @param qqNum
	 * 		QQ号
	 * @return
	 * 		true表示有临时会话消息未读
	 */
	public boolean hasTempSessionMessage(int qqNum) {
		return tempSessionQueueMap.containsKey(qqNum);
	}
	
	/**
	 * 得到下一条临时会话消息
	 * 
	 * @param qqNum
	 * @return
	 */
	public InPacket getTempSessionMessage(int qqNum) {
		if(hasTempSessionMessage(qqNum)) {
			Queue<InPacket> tempQueue = tempSessionQueueMap.get(qqNum);
			InPacket p = tempQueue.poll();
			if(p == null)
				return null;
			// 从总队列中删除
			queue.remove(p);
			// 如果用户消息队列为空，删除这个队列
			if(tempQueue.isEmpty())
				tempSessionQueueMap.remove(qqNum);
			return p;
		} else
			return null;
	}
	
	/**
	 * 得到下一条临时会话消息，不从队列中删除
	 * 
	 * @param qqNum
	 * @return
	 */
	public InPacket peekTempSessionMessage(int qqNum) {
		if(hasTempSessionMessage(qqNum)) {
			Queue<InPacket> tempQueue = tempSessionQueueMap.get(qqNum);
			return tempQueue.peek();
		} else
			return null;
	}
	
	/**
	 * 检查是否某个群下面有讨论组的消息，如果父群id是0，则检查
	 * 是否有多人对话消息
	 * 
	 * @param parentClusterId
	 * 		父群id，0表示多人对话容器
	 * @return
	 * 		子群id，如果为-1表示没有子群有消息
	 */
	public int hasSubClusterIM(int parentClusterId) {
		for(InPacket p : queue) {
			if(p instanceof ReceiveIMPacket) {
			    ReceiveIMPacket packet = (ReceiveIMPacket)p;
			    switch(packet.header.type) {
			    	case QQ.QQ_RECV_IM_TEMP_CLUSTER:
			    		if(packet.clusterIM.externalId == parentClusterId)
			    			return packet.clusterIM.clusterId;
			    	default:
			    		break;
			    }
			}
		}
		return -1;
	}
	
	/**
	 * 检查某个组是否有消息未读
	 * 
	 * @param g 
	 * 		Group
	 * @return 
	 * 		true如果有消息未读
	 */
	public boolean hasGroupMessage(Group g) {
		return nextGroupSender(g) != -1;
	}

	/**
	 * @return 
	 * 		true如果还有任何消息未读
	 */
	public boolean hasNext() {
		return !queue.isEmpty();
	}

	/**
	 * @return 
	 * 		true如果还有系统消息未读
	 */
	public boolean hasSystemMessage() {
		return !sysQueue.isEmpty();
	}
	
	/**
	 * @return 
	 * 		true如果还有短消息
	 */
	public boolean hasSMS() {
	    return !smsQueue.isEmpty();
	}
	
	/**
	 * 好友的下一条消息是不是临时会话消息
	 * 
	 * @param qq
	 * @return
	 */
	public boolean isNextTempSessionMessage(int qq) {
		InPacket normal = peekMessage(qq);
		InPacket temp = peekTempSessionMessage(qq);
		if(temp == null && normal == null)
			return false;
		if(temp == null)
			return false;
		for(InPacket in : queue) {
			if(in == normal)
				return false;
			if(temp == in)
				return true;
		}
		return false;
	}

	/**
	 * @return 
	 * 		下一条消息的发送者的QQ号，如果是0，表示是系统消息，-1表示
	 * 		无消息如果是群消息，返回的将是群的内部ID
	 */
	public int nextSender() {
		InPacket packet = queue.peek();
		if(packet == null)
			return -1;

		if(packet instanceof ReceiveIMPacket) {
			ReceiveIMPacket im = (ReceiveIMPacket)packet;
			if(im.header.type == QQ.QQ_RECV_IM_SYS_MESSAGE)
				return 0;
			else if(im.header.type == QQ.QQ_RECV_IM_TEMP_CLUSTER)
			    return im.clusterIM.clusterId;
			else
				return im.header.sender;
		} else
			return 0;
	}
	
	/**
	 * 返回下一个消息的来源，对于普通消息，返回QQ_IM_FROM_FRIEND，对于
	 * 系统消息，返回QQ_IM_FROM_SYS，对于群消息，有两种情况，因为群消息
	 * 包含了普通消息和通知消息，对于普通消息，我们返回QQ_IM_FROM_CLUSTER，
	 * 对于通知消息，我们返回QQ_IM_FROM_SYS
	 * 
	 * @return
	 * 		消息来源标识常量
	 */
	public int nextMessageSource() {
		InPacket packet = queue.peek();
		if(packet == null)
			return -1;
		
		if(packet instanceof ReceiveIMPacket) {
			ReceiveIMPacket im = (ReceiveIMPacket)packet;
			return im.getMessageCategory();
		} else
			return QQ.QQ_IM_FROM_SYS;
	}
	
	/**
	 * 返回该组内下一条消息发送者的QQ号
	 * 
	 * @param g
	 * 		Group
	 * @return
	 * 		QQ号，如果没有消息，返回-1
	 */
	public int nextGroupSender(Group g) {
		for(InPacket p : queue) {
			if(p instanceof ReceiveIMPacket) {
			    ReceiveIMPacket packet = (ReceiveIMPacket)p;
			    if(packet.header.type == QQ.QQ_RECV_IM_BIND_USER || packet.header.type == QQ.QQ_RECV_IM_MOBILE_QQ) 
			        continue;
				// 得到下一个包的发送者QQ号		
			    int sender = packet.header.sender;
			    if(packet.header.type == QQ.QQ_RECV_IM_TEMP_CLUSTER)
			    	sender = packet.clusterIM.clusterId;
				// 在g指定的组中查找是否有这个好友
			    if(ModelRegistry.hasUser(sender)) {
			    	if(ModelRegistry.getUser(sender).group == g)
			    		return sender;
			    } else if(ModelRegistry.hasCluster(sender)) {
			    	if(ModelRegistry.getCluster(sender).group == g)
			    		return sender;
			    }
			}
		}
		return -1;
	}
	
	/**
	 * @return
	 * 		下一个应该闪烁的消息的发送者
	 */
	public int nextBlinkableIMSender() {
		for(InPacket p : queue) {
			if(p instanceof ReceiveIMPacket) {
			    ReceiveIMPacket packet = (ReceiveIMPacket)p;
			    switch(packet.header.type) {
			    	case QQ.QQ_RECV_IM_FRIEND: 
			    	case QQ.QQ_RECV_IM_STRANGER:
			    	case QQ.QQ_RECV_IM_TEMP_SESSION:
			    		return packet.header.sender;
			    	default:
			    		break;
			    }
			}
		}
		return -1;
	}
	
	/**
	 * @return
	 * 		下一条群消息的群号，-1表示没有
	 */
	public int nextClusterIMSender() {
		for(InPacket p : queue) {
			if(p instanceof ReceiveIMPacket) {
			    ReceiveIMPacket packet = (ReceiveIMPacket)p;
			    switch(packet.header.type) {
			    	case QQ.QQ_RECV_IM_CLUSTER:
			    		return packet.header.sender;
			    	case QQ.QQ_RECV_IM_TEMP_CLUSTER:
			    		return packet.clusterIM.clusterId;
			    	default:
			    		break;
			    }
			}
		}
		return -1;
	}
	
	/**
	 * 一个消息在好友列表还没得到之前到达了，延迟处理这个消息
	 * 
	 * @param packet 
	 * 		消息包
	 */
	public void postponeMessage(InPacket packet) {
		postponeQueue.offer(packet);
	}
	
	/**
	 * 返回下一个延迟处理的消息
	 * 
	 * @return 
	 * 		如果有则返回消息，没有返回null
	 */
	public InPacket getPostponedMessage() {
		return postponeQueue.poll();
	}

	/**
	 * @return Returns the postpone.
	 */
	public synchronized boolean isPostpone() {
		return postpone;
	}

	/**
	 * @param postpone The postpone to set.
	 */
	public synchronized void setPostpone(boolean postpone) {
		this.postpone = postpone;
	}
}