evapacketmanager.cpp

linux下的eva源代码

		break;
	case QQ_QUN_CMD_JOIN_QUN:
		emit joinQunReply(packet->getQunID(), packet->getJoinReply(), codec->toUnicode( packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_JOIN_QUN_AUTH:
		emit joinQunAuthReply(packet->getQunID(), packet->getReplyCode());
		break;
	case QQ_QUN_CMD_MODIFY_QUN_INFO:
		if(packet->isReplyOK())
			doRequestQunInfo(packet->getQunID());
		emit qunModifyInfoReply(packet->getQunID(), packet->isReplyOK(), codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_SEARCH_QUN:
		emit qunSearchReady(packet->getQunInfoList(), codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_GET_TEMP_QUN_INFO:
		break;
	case QQ_QUN_CMD_EXIT_TEMP_QUN:
		break;
	case QQ_QUN_CMD_GET_TEMP_QUN_MEMBERS:
		break;
	case QQ_QUN_CMD_MODIFY_CARD:
		emit qunModifyQunCardReply(packet->getQunID(), packet->isReplyOK(), packet->getTargetQQ(),
							 codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_REQUEST_ALL_REALNAMES:
		if(packet->isReplyOK()){
			QunList *qunList = user->getQunList();
			if(!qunList) break;
			Qun *qun = qunList->getQun( packet->getQunID());
			if(!qun) break;
			if(qun->getRealNamesVersion() == packet->getCardVersion())
				break;

			std::map<int, std::string> nameList = packet->getRealNames();
			std::map<int, std::string>::iterator it;
			FriendItem *member = 0;
			FriendItem *item = 0;
			for(it = nameList.begin(); it != nameList.end(); ++it){
				member = qun->memberDetails( it->first);
				if(!member) { // new member not existed in our list
					printf("New Qun member found when getting member real names!\n");
					printf("\t -- id: %d, real name(Qun card): %s\n", it->first, codec->toUnicode(it->second.c_str()).local8Bit().data());
					item = new FriendItem(it->first);
				} else { // we already have this member
					item = new FriendItem(*member);
				}
				item->setQunRealName( it->second);
				qun->setMember( *item);
				delete item;
			}
			if(nameList.size()) {
			}
			if(packet->getNextStartIndex()){
				QunRequestAllRealNames *all = new QunRequestAllRealNames(packet->getQunID());
				all->setStartIndex(packet->getNextStartIndex());
				connecter->append(all);
			} else { // we got all members' real names
				qun->setRealNamesVersion(packet->getCardVersion());
				user->saveQunList();
				emit qunMemberInfoReady(packet->getQunID());
			}
		}
		break;
	case QQ_QUN_CMD_REQUEST_CARD:
		if(packet->isReplyOK() && (packet->getTargetQQ() == user->getQQ()) )
			user->getQunList()->setMyQunCardInfo(packet->getQunID(), packet->getRealName(), packet->getGender(),
						packet->getPhone(), packet->getEmail(), packet->getMemo());
		emit qunRequestQunCardReply(packet->getQunID(), packet->isReplyOK(), packet->getTargetQQ(),
					codec->toUnicode(packet->getRealName().c_str()), packet->getGender(),
					codec->toUnicode(packet->getPhone().c_str()),codec->toUnicode(packet->getEmail().c_str()),
					codec->toUnicode(packet->getMemo().c_str()),codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_ADMIN:
		if(packet->isReplyOK())
			doRequestQunInfo(packet->getQunID());
		emit qunSetAdminReply(packet->getQunID(), packet->isReplyOK(), packet->getTargetQQ(),
					(packet->getOpCode() == QQ_QUN_SET_ADMIN), codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	case QQ_QUN_CMD_TRANSFER:
		if(packet->isReplyOK())
			doRequestQunInfo(packet->getQunID());
		emit qunTransferReply(packet->getQunID(), packet->isReplyOK(), packet->getTargetQQ(),
						  codec->toUnicode(packet->getErrorMessage().c_str()));
		break;
	default:
		printf("Unknown qun operation reply\n");
	}
	delete packet;
}

void EvaPacketManager::doRequestQunInfo( const unsigned int id )  // note that the id should be the internal Qun ID
{
	if(processQunID) return;
	processQunID = id;
	connecter->append(new QunGetInfoPacket(id));
}

void EvaPacketManager::doRequestQunMemberInfo( const unsigned int id , const std::list<unsigned int> &l)
{
	QunGetMemberInfoPacket *packet = new QunGetMemberInfoPacket(id);
	packet->setMemberList(l);
	connecter->append(packet);
}

void EvaPacketManager::doRequestQunOnlineMembers( const unsigned int id )
{
	connecter->append(new QunGetOnlineMemberPacket(id));
}

void EvaPacketManager::doSendQunMessage( const unsigned int receiver, QString & message, const char fontSize, 
					const bool u, const bool i, const bool b, 
					const char blue, const char green, const char red )
{
	QString rNick = QString::number(receiver);
	QString sNick = codec->toUnicode(user->getDetails().at(ContactInfo::Info_nick).c_str());
	Qun *qun = user->getQunList()->getQun(receiver);
	if(qun){
		QunInfo info = qun->getDetails();
		rNick = codec->toUnicode(info.getName().c_str());

		const FriendItem *item = qun->getMemberDetails(user->getQQ());
		if(item)
			sNick  = codec->toUnicode(item->getQunRealName().c_str());
	}

	QDateTime time = QDateTime::currentDateTime(Qt::LocalTime);	
	user->getSetting()->saveMessage(receiver,  user->getQQ(), sNick, receiver, rNick,
				true, message, time, fontSize, u, i, b, blue, green, red, true);
	

	QCString str = codec->fromUnicode(message);
	unsigned short pcs = strlen(str.data()) / 700;
	QunSendIMExPacket *firstPacket = 0;
	int lastSeq = 0;
	
	for (unsigned short pcsn=0; pcsn<=pcs; pcsn++)
	{
		QunSendIMExPacket *packet = new QunSendIMExPacket(receiver);
		packet->setNumFragments(pcs + 1);
		packet->setSeqOfFragments(pcsn);
		//memcpy(&packet->pieceInfo[2], &opID, 2);
		
		packet->setFontSize(fontSize);
		packet->setUnderline(u); 
		packet->setItalic(i);
		packet->setBold(b);
		packet->setBlue(blue);
		packet->setGreen(green);
		packet->setRed(red);
		//QCString str = codec->fromUnicode(message);
		//packet->setMessage(str.data());
		packet->setMessage(str.mid(pcsn * 700, 700).data());
		if(!pcsn) {
			firstPacket = packet;
			lastSeq = firstPacket->getSequence();
		} else {
			longMsgQunPacketQueue[lastSeq] = packet; // record the next packet
			lastSeq = packet->getSequence();
			if(pcsn == (pcs - 1))  // the last sent packet points to NULL
				longMsgQunPacketQueue[lastSeq] = NULL;
		}
	}
	connecter->append(firstPacket);
}

void EvaPacketManager::doSearchQun( const unsigned int extID )
{
	QunSearchPacket *packet = new QunSearchPacket();
	packet->setExtID(extID);
	connecter->append(packet);
}

void EvaPacketManager::doJoinQun( const unsigned int qunID )
{
	QunJoinPacket *packet = new QunJoinPacket(qunID);
	connecter->append(packet);
}

void EvaPacketManager::doJoinQunAuth( const unsigned int qunID , const unsigned char *code, const unsigned short len, const QString &message)
{
	printf("code len: %d\n", len);
	QunAuthPacket *packet = new QunAuthPacket(qunID, QQ_QUN_AUTH_REQUEST);
	std::string msg = (codec->fromUnicode(message)).data();
	packet->setCode( code, len);
	packet->setMessage(msg);
	connecter->append(packet);
}

void EvaPacketManager::doApproveQun( const unsigned int id, const unsigned int qunID,
					const unsigned char *token, const unsigned short len)
{
	QunAuthPacket *packet = new QunAuthPacket(qunID, QQ_QUN_AUTH_APPROVE);
	packet->setReceiver(id);
	packet->setToken( token, len);
	connecter->append(packet);
}

void EvaPacketManager::doRejectQun( const unsigned int id, const unsigned int qunID, const QString & message,
				const unsigned char *token, const unsigned short len)
{	
	QunAuthPacket *packet = new QunAuthPacket(qunID, QQ_QUN_AUTH_REJECT);
	packet->setReceiver(id);
	packet->setToken(token, len);
	std::string msg = (codec->fromUnicode(message)).data();
	packet->setMessage(msg);
	connecter->append(packet);
}

void EvaPacketManager::doGetAllLevels( )
{
	std::list<unsigned int> list;
	list.push_back(user->getQQ());
	
	std::list<QQFriend> friends = user->getFriendList().getAllFriends();
	std::list<QQFriend>::iterator iter;
	
	int i = 0;
	for(iter = friends.begin(); iter!=friends.end(); ++iter){
		list.push_back(iter->getQQ());
		i++;
		if(i==70){
			EvaGetLevelPacket *packet = new EvaGetLevelPacket(list);
			connecter->append(packet);
			list.clear();
			i=0;
		}
	}

	if(list.size()){
		EvaGetLevelPacket *packet = new EvaGetLevelPacket(list);
		connecter->append(packet);
	}
}

void EvaPacketManager::requestFriendLevel(const unsigned int id)
{
	std::list<unsigned int> list;
	list.push_back(id);
	EvaGetLevelPacket *packet = new EvaGetLevelPacket(list);
	connecter->append(packet);
}

void EvaPacketManager::processGetLevelReply( const InPacket * in )
{
	EvaGetLevelReplyPacket *packet = new EvaGetLevelReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	
	std::list<LevelUserItem> friends = packet->getLevelList();
	std::list<LevelUserItem>::iterator iter;
	for(iter = friends.begin(); iter != friends.end(); ++iter){
		if(iter->qqNum == user->getQQ()){
			user->setOnlineTime(iter->onlineTime);
			user->setLevel(iter->level);
			user->setHoursToLevelUp(iter->timeRemainder);
		}else
			user->getFriendList().updateFriendLevel(iter->qqNum, iter->onlineTime, iter->level, iter->timeRemainder);
		
	}
	delete packet;
}

void EvaPacketManager::doModifyQunInfo( const unsigned int id, unsigned char auth, unsigned short cate, 
					QString name, QString notice, QString description )
{
	user->getSetting()->removeFromQunRejectForever(id); // clear setting to allow join requests
	user->getSetting()->saveSettings();

	std::string qunName = (codec->fromUnicode(name)).data();
	std::string qunNotice = (codec->fromUnicode(notice)).data();
	std::string qunDescription = (codec->fromUnicode(description)).data();
	
	QunInfo info;
	info.setQunID(id);
	info.setAuthType(auth);
	info.setCategory(cate);
	info.setName(qunName);
	info.setNotice(qunNotice);
	info.setDescription(qunDescription);
	connecter->append(new QunModifyPacket(info));
}

void EvaPacketManager::doModifyQunCard(const unsigned int id,  const unsigned int qqID, QString name, unsigned char gender, 
				QString phone, QString email, QString memo )
{
	QunModifyCardPacket *packet = new QunModifyCardPacket(id, qqID);
	
	std::string cardName = codec->fromUnicode(name).data(); 
	std::string cardPhone = codec->fromUnicode(phone).data();
	std::string cardEmail = codec->fromUnicode(email).data();
	std::string cardMemo = codec->fromUnicode(memo).data();
	
	packet->setName(cardName);
	packet->setGender(gender);
	packet->setPhone(cardPhone);
	packet->setEmail(cardEmail);
	packet->setMemo(cardMemo);
	connecter->append(packet);
}

void EvaPacketManager::doQunSetAdmin( const unsigned int id, const unsigned int qq, const bool isSetAdmin )
{
	connecter->append(new QunAdminOpPacket(id, qq, isSetAdmin));
}

void EvaPacketManager::doQunTransfer( const unsigned int id, const unsigned int qq )
{
	connecter->append(new QunTransferPacket(id, qq));
}

void EvaPacketManager::doModifyQunMembers( const unsigned int id, const std::list< unsigned int > members, const bool isAdd )
{
	user->getSetting()->removeFromQunRejectForever(id); // clear setting to allow join requests
	user->getSetting()->saveSettings();

	QunModifyMemberPacket *packet = new QunModifyMemberPacket(id, isAdd);
	packet->setMembers(members);
	connecter->append(packet);
}

void EvaPacketManager::processRequestKeyReply( const InPacket * in )
{
	EvaRequestKeyReplyPacket *packet = new EvaRequestKeyReplyPacket();
	packet->setInPacket(in);
	packet->parse();
	delete packet;
	if(packet->getKeyType() == QQ_REQUEST_FILE_AGENT_KEY){
		user->loginManager()->finishedCommand(QQ_CMD_REQUEST_KEY);
	}
	emit fileAgentInfoReady();
}

void EvaPacketManager::doRequestQunCard( const unsigned int id, const unsigned int qq )
{
	printf("doRequestQunCard\n");
	connecter->append(new QunRequestCardPacket(id, qq));
}

void EvaPacketManager::doQunExit( const unsigned int id )
{
	connecter->append(new QunExitPacket(id));
}

void EvaPacketManager::doQunCreate( const QString & name, const unsigned short category, const unsigned char auth, 
				const QString & notice, const QString & description, const std::list< unsigned int > & members )
{
	QCString _name = codec->fromUnicode(name);
	QCString _notice = codec->fromUnicode(notice);
	QCString _description = codec->fromUnicode(description);
	
	QunCreatePacket *packet = new QunCreatePacket(_name.data(), category, auth);
	packet->setNotice(_notice.data());
	packet->setDescription(_description.data());
	packet->setMembers(members);
	connecter->append(packet);
}

void EvaPacketManager::doRequestExtraInfo( )
{
	connecter->append(new RequestExtraInfoPacket());
}

void EvaPacketManager::processRequestExtraInfoReply(const InPacket *in)
{
	RequestExtraInfoReplyPacket *packet = new RequestExtraInfoReplyPacket();
	packet->setInPacket(in);
	if(!packet->parse()){
		delete packet;
		return;
	}
	if(packet->getReplyCode() != 1){
		delete packet;
		return;
	}
	std::map<unsigned int, unsigned long long> members = packet->getMembers();
	std::map<unsigned int, unsigned long long>::iterator iter;
	for(iter = members.begin(); iter!= members.end(); ++iter){
		if(iter->first == user->getQQ())
			user->setExtraInfo(iter->second);
		else
			user->getFriendList().setExtraInfo(iter->first, iter->second);
	}
	if(packet->getOffset()!=QQ_FRIEND_LIST_POSITION_END){
		connecter->append(new RequestExtraInfoPacket(packet->getOffset()));
	}else{
		emit extraInfoReady();
		doRequestSignature();
	}
	delete packet;
}

void EvaPacketManager::doModifySignature( const QString