evapacketmanager.cpp

linux下的eva源代码

	}else{
		emit friendGroupsReady();
		QunList *qunList = user->getQunList();
		if(qunList && qunList->numQuns()){
			doRequestQunInfo(qunList->getQunList().begin()->getQunID());
		}
	}
	delete packet;
}

void EvaPacketManager::processUploadGroupFriendReply(const InPacket *in)
{
	UploadGroupFriendReplyPacket *packet = new UploadGroupFriendReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	if(packet->uploadOk()) 
		emit friendGroupsUploadReady(true);
	else
		emit friendGroupsUploadReady(false);
	
	delete packet;
}

void EvaPacketManager::doDeleteBuddy( const unsigned int id )
{
	if(deletingBuddyQQ)
		return;
	deletingBuddyQQ = id;
	DeleteFriendPacket *packet = new DeleteFriendPacket(id);
	saveBuddyQQ(id, packet->getSequence());
	connecter->append(packet);
}

void EvaPacketManager::processDeleteFriendReply( const InPacket * in )
{
	DeleteFriendReplyPacket *packet = new DeleteFriendReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	if(packet->isDeleted()){
		user->getFriendList().deleteFriend(deletingBuddyQQ);
		user->saveGroupedBuddyList();
	}
	deletingBuddyQQ = 0;
	int id = getSavedBuddyQQ(packet->getSequence());
	if(id==-1) {
		delete packet;
		return;
	}
	removeSequence(packet->getSequence());
	emit deleteBuddyReady(id, packet->isDeleted());	
	delete packet;
}

void EvaPacketManager::doAddBuddy( const unsigned int id )
{
	if(addingBuddyQQ) {
		emit addingBuddy(addingBuddyQQ);
		return;
	}
	addingBuddyQQ = id;
	connecter->append(new AddFriendPacket(id));
}

void EvaPacketManager::processAddFriendReply( const InPacket * in )
{
	AddFriendReplyPacket *packet = new AddFriendReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	switch(packet->getReplyCode()){
	case QQ_AUTH_NO_AUTH:{
		QQFriend frd(addingBuddyQQ, 0);
		user->getFriendList().addFriend(frd);
		addingBuddyQQ = 0;
		emit addBuddyReady();
		}
		break;
	case QQ_AUTH_NEED_AUTH:
		addingBuddyQQ = 0;
		emit addBuddyNeedAuth();
		break;
	case QQ_AUTH_NO_ADD:
		addingBuddyQQ = 0;
		emit addBuddyRejected();
		break;
	}
	delete packet;	
}

void EvaPacketManager::doAddAuthBuddy( const unsigned int id, const QString &message)
{
	AddFriendAuthPacket *packet = new AddFriendAuthPacket(id, QQ_MY_AUTH_REQUEST);
	QCString msg = codec->fromUnicode(message);
	packet->setMessage(msg.data());
	connecter->append(packet);
}

void EvaPacketManager::doApproveBuddy( const unsigned int id)
{
	AddFriendAuthPacket *packet = new AddFriendAuthPacket(id, QQ_MY_AUTH_APPROVE);
	connecter->append(packet);
}

void EvaPacketManager::doRejectBuddy( const unsigned int id , const QString &message)
{
	AddFriendAuthPacket *packet = new AddFriendAuthPacket(id, QQ_MY_AUTH_REJECT);
	QCString msg = codec->fromUnicode(message);
	packet->setMessage(msg.data());
	connecter->append(packet);
}

void EvaPacketManager::processAddFriendAuthReply( const InPacket * in )
{
	AddFriendAuthReplyPacket *packet = new AddFriendAuthReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	emit addBuddySentToServer(packet->isSentOK());
	delete packet;
}

void EvaPacketManager::processSystemNotification( const InPacket * in )
{
	SystemNotificationPacket *packet = new SystemNotificationPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	if(packet->getType() == QQ_MSG_SYS_ADD_FRIEND_REQUEST_EX){
		if(user->getSetting()->isInRejectForever( packet->getFromQQ())){
			delete packet;
			return;
		}
	}

	QString msg = codec->toUnicode(packet->getMessage().c_str());

	emit receivedSysMessage(packet->getType(), packet->getMyQQ(), packet->getFromQQ(),
				 msg, packet->allowReverse(), packet->getCode(), packet->getCodeLength());

	delete packet;
}

void EvaPacketManager::doModifyDetails(QStringList info, QString oldPwd, QString newPwd)
{
	std::vector<std::string> result;
	for(uint i=0; i< info.count(); i++){
		printf("changing my details[%d]:%s\n", i, info[i].local8Bit().data());
		result.push_back((codec->fromUnicode(info[i])).data());
	}
	changingDetails.setDetails(result);
	ModifyInfoPacket *packet = new ModifyInfoPacket(changingDetails);
	if(oldPwd != QString::null && newPwd != QString::null){
		std::string o, n;
		o = codec->fromUnicode(oldPwd).data();
		n = codec->fromUnicode(newPwd).data();
		packet->setPassword(o);
		packet->setNewPassword(n);
	}
	connecter->append(packet);
}

void EvaPacketManager::processModifyInfoReply(const InPacket *in)
{
	ModifyInfoReplyPacket *packet = new ModifyInfoReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	if(packet->isAccepted()){
		user->setDetails(changingDetails);
		user->saveGroupedBuddyList();
		emit myInfoReady();
		emit modifyInfo(true);
	}else
		emit modifyInfo(false);
	delete packet;
}

QStringList EvaPacketManager::convertDetails(const ContactInfo &info)
{
	QStringList result;
	for(uint i=0; i< info.count(); i++){
		result.append(codec->toUnicode(info.at(i).c_str()));
	}
	return result;
}

void EvaPacketManager::doSearchUsers( const bool isSearchAll, const QString page, const QString id, 
				const QString nick, const QString email, const bool match )
{
	SearchUserPacket *packet = new SearchUserPacket();
	if(!isSearchAll){
		packet->setSearchType(nick.isEmpty()?QQ_SEARCH_QQ:QQ_SEARCH_NICK);
		packet->setPage(codec->fromUnicode(page).data());
		packet->setQQ(codec->fromUnicode(id).data());
		packet->setNick(codec->fromUnicode(nick).data());
		packet->setEmail(codec->fromUnicode(email).data());
		packet->setMatchEntireString(match);
	}
        connecter->append(packet);
}

void EvaPacketManager::processSearchUserReply( const InPacket * in )
{
	SearchUserReplyPacket *packet = new SearchUserReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}

	emit searchUsersReady(packet->isFinished(), packet->getUsers());
	delete packet;
}

void EvaPacketManager::doDeleteMeFrom( const unsigned int id )
{
	DeleteMePacket *packet = new DeleteMePacket(id);
	connecter->append(packet);
}

void EvaPacketManager::processDeleteMeReply( const InPacket * in )
{
	DeleteMeReplyPacket *packet = new DeleteMeReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	emit deleteMeReady(packet->isDeleted());
	delete packet;
}

void EvaPacketManager::processQunReply( const InPacket * in )
{
	QunReplyPacket *packet = new QunReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}

	switch(packet->getQunCommand()){
	case QQ_QUN_CMD_SEND_IM:
	case QQ_QUN_CMD_SEND_IM_EX:{
		// check if there are more sub packets to send
		std::map<int, QunSendIMExPacket*>::iterator iter = longMsgQunPacketQueue.find(packet->getSequence());
		if(iter == longMsgQunPacketQueue.end()){
			// last packet should be a one-shot message
			emit qunSentMessageResult(packet->getQunID() ,
								packet->isReplyOK(), 
								codec->toUnicode(packet->getErrorMessage().c_str()));
		} else {
			// got it in the long message queue
			QunSendIMExPacket *next = iter->second;  // next packet
			
			// erase the last sent sequence entry
			longMsgQunPacketQueue.erase(packet->getSequence());
	
			if(packet->isReplyOK()){
				// if sent ok, try to send next
				connecter->append(next);
				printf("Qun msg next fragment sent!\n");
			}else{
				// if any one fragment of the long message got error back, chuck all fragments
				int nextSeq = next->getSequence();
				while(next){
					longMsgQunPacketQueue.erase(next->getSequence());
					next = longMsgQunPacketQueue[nextSeq];
					nextSeq = next->getSequence();
				}
				emit qunSentMessageResult(packet->getQunID() ,
									packet->isReplyOK(), 
									codec->toUnicode(packet->getErrorMessage().c_str()));
			}
		}
		}
		break;
	case QQ_QUN_CMD_SEND_TEMP_QUN_IM:
		break;
	case QQ_QUN_CMD_CREATE_QUN:
		if(packet->isReplyOK()){
			Qun q(packet->getQunID());
			user->getQunList()->add(q);
			doRequestQunInfo(packet->getQunID());
			emit qunCreateDone(packet->getQunID());
			connecter->append(new QunActivePacket(packet->getQunID()));
			emit qunRequestUpdateDisplay();
		}else
			emit qunCreateFailed(codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_CREATE_TEMP_QUN:
		break;
	case QQ_QUN_CMD_ACTIVATE_QUN:
		if(!packet->isReplyOK())
			emit qunActiveQunFailed(codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_MODIFY_MEMBER:
		if(packet->isReplyOK())
			doRequestQunInfo(packet->getQunID());
		emit qunModifyQunMembersReply(packet->getQunID(), packet->isReplyOK(), codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_GET_QUN_INFO:{
		if(!packet->isReplyOK()){
			// note that if comes here, the packet->getQunID() won't get the right id, only error message is ok
			emit qunInfomationReady(processQunID, packet->isReplyOK(), codec->toUnicode(packet->getErrorMessage().c_str()));
			printf("QQ_QUN_CMD_GET_QUN_INFO --  reply code: %d\n",packet->getReplyCode());
			switch(packet->getReplyCode()){
			case 3: // qun has been dismissed
				user->getQunList()->remove(processQunID);
				user->saveQunList();
				emit qunRequestUpdateDisplay();
				break;
			default:break;
			}
			processQunID = 0;
			return;
		}

		QunInfo info = packet->getQunInfo();
		user->getQunList()->setDetails(info);
		user->getQunList()->setMemberArgs(info.getQunID(), packet->getMemberList());
		emit qunInfomationReady(info.getQunID(), packet->isReplyOK(), codec->toUnicode(packet->getErrorMessage().c_str()));
		if( ! (user->getQunList()->getQun( info.getQunID() ))) return;

		std::map<unsigned int, QunMember>::iterator iter;
		std::map<unsigned int, QunMember> lst = packet->getMemberList();
		std::list<unsigned int> toSend;
		int i=0;
		qunMemberInfoFinished = false;

		for(iter= lst.begin(); iter != lst.end(); ++iter){
			if(i==30){
				doRequestQunMemberInfo(info.getQunID(), toSend);
				toSend.clear();
				i = 0;
			}
			toSend.push_back(iter->second.qqNum);
			i++;
		}
		if(toSend.size())
			doRequestQunMemberInfo(info.getQunID(), toSend);

		qunMemberInfoFinished = true;
		processQunID = 0;
		std::list<Qun>::iterator qunIter;
		std::list<Qun> list = user->getQunList()->getQunList();
		for(qunIter = list.begin(); qunIter != list.end(); ++qunIter){
			QunInfo info = qunIter->getDetails();
			if(info.getExtID() == 0){
				doRequestQunInfo(qunIter->getQunID());
				break;
			}
		}
 		}
		break;
	case QQ_QUN_CMD_EXIT_QUN:
		emit qunExitReply(packet->getQunID(), packet->isReplyOK(), codec->toUnicode(packet->getErrorMessage().c_str()));
		if(packet->isReplyOK()){
			user->getQunList()->remove(packet->getQunID());
			user->saveQunList();
			emit qunRequestUpdateDisplay();
		}
		break;
	case QQ_QUN_CMD_GET_MEMBER_INFO:{
			user->getQunList()->setMembers(packet->getQunID(), packet->getMemberInfoList());
			if(!qunMemberInfoFinished) break;
			user->saveQunList();
			emit qunMemberInfoReady(packet->getQunID());
		}
		break;
	case QQ_QUN_CMD_GET_ONLINE_MEMBER:{
		if(packet->isReplyOK()){
			user->getQunList()->setOnlineMembers(packet->getQunID(), packet->getQQNumberList());
			emit qunOnlineListReady(packet->getQunID());
		}else{
			// most likely, you are not a member of this Qun any mare
			QString msg = codec->toUnicode(packet->getErrorMessage().c_str());
			printf("QQ_QUN_CMD_GET_ONLINE_MEMBER -- reply code: %d, error msg: %s\n", packet->getReplyCode(), msg.local8Bit().data());
			user->getQunList()->remove(packet->getQunID());
			user->saveQunList();
			emit qunRequestUpdateDisplay();
			//emit qunSentMessageResult(packet->getQunID(), packet->isReplyOK(), codec->toUnicode(packet->getErrorMessage().c_str()));
		}
		}