evafiledownloader.cpp

linux 下最好用的 QQ 客房端。支持传文件

	m_State = ENone;
}

void EvaAgentUploader::doSendInfo()
{
	unsigned char *md5 = new unsigned char[16];
	if(!m_File->getSourceFileMd5((char *)md5)){
		m_State = EError;
		delete []md5;
		return;
	}
	
	EvaFTAgentTransfer *TransferPacket = new EvaFTAgentTransfer(QQ_FILE_AGENT_TRANSFER_INFO);

	QTextCodec *codec = QTextCodec::codecForName("GB18030");
	TransferPacket->setInfo(codec->fromUnicode(m_FileName).data(),md5, m_File->getFileSize());
	send(TransferPacket);
	delete []md5;
	m_IsSendingStart = false;
	m_State = ENone;
	printf("EvaAgentUploader::doSendInfo -- sent: %s\n", codec->fromUnicode(m_FileName).data());
}

// we send 50 packets, if it has 50, every time
void EvaAgentUploader::doDataTransfering()
{
	m_State = ETransfering;
// 	EvaFTAgentTransfer *packet;
// 	unsigned int bytesSent = 0, bytesToSend = 0;
// 	unsigned int bufferLength = 50 * EVA_FILE_BUFFER_UNIT;
// 	unsigned char *buf = new unsigned char [bufferLength];
// 	bufferLength = m_File->getFragment(m_BytesSent, bufferLength, buf);

	m_NumPackets = 0;
	m_OutBytesSent = 0;
	m_OutBufferLength = 50 * EVA_FILE_BUFFER_UNIT;
	m_OutBufferLength = m_File->getFragment(m_BytesSent, m_OutBufferLength, m_OutBuffer);
	m_Connecter->setWriteNotifierEnabled(true);
	printf("EvaAgentUploader::doDataTransfering\n");
// 	for(int i = 0; i<50; i++){
// 		m_Sequence++;
// 		packet = new EvaFTAgentTransfer(QQ_FILE_AGENT_TRANSFER_DATA);
// 		bytesToSend = ((bufferLength - bytesSent)>EVA_FILE_BUFFER_UNIT)?EVA_FILE_BUFFER_UNIT:(bufferLength - bytesSent);
// 		packet->setData(buf + bytesSent, bytesToSend);
// 		send(packet);
// 		if(!(i%10)) notifyTransferStatus();
// 		msleep(10);
// 		bytesSent += bytesToSend;
// 		if(bytesSent >= bufferLength) break;
// 		if(m_ExitNow) break;
// 	}
// 	m_BytesSent += bufferLength;
// 	delete []buf;
// 	m_State = ENone;
}

void EvaAgentUploader::slotWriteReady()
{
	m_Connecter->setWriteNotifierEnabled(false);
	if(m_State != ETransfering){
		return;
	}
	printf("EvaAgentUploader::slotWriteReady\n");
	//unsigned int bytesSent = 0, bytesToSend = 0;
	//unsigned int bufferLength = 50 * EVA_FILE_BUFFER_UNIT;
	//unsigned char *buf = new unsigned char [bufferLength];
	//bufferLength = m_File->getFragment(m_BytesSent, bufferLength, buf);
	
	m_Sequence++;
	EvaFTAgentTransfer *packet = new EvaFTAgentTransfer(QQ_FILE_AGENT_TRANSFER_DATA);
	unsigned int bytesToSend = ((m_OutBufferLength - m_OutBytesSent)>EVA_FILE_BUFFER_UNIT)?EVA_FILE_BUFFER_UNIT:(m_OutBufferLength - m_OutBytesSent);
	packet->setData(m_OutBuffer + m_OutBytesSent, bytesToSend);
	send(packet);
	m_OutBytesSent += bytesToSend;
	m_BytesSent += bytesToSend;
	m_NumPackets++;
	if(!(m_NumPackets%10)) notifyTransferStatus();
	if(m_NumPackets == 50 || m_OutBytesSent >= m_OutBufferLength ){
		m_State = ENone;
		return;
	}
	m_Connecter->setWriteNotifierEnabled(true);
}

void EvaAgentUploader::doFinishProcessing()
{	
	notifyTransferStatus();
	notifyNormalStatus(ESSendFinished);
	if(m_FileList.remove()){
		if(!m_FileList.count()){
			m_ExitNow = true;
			return;
		} 
		m_File = m_FileList.first();
		if(!m_File)
			m_ExitNow = true;
		m_Dir = m_File->getDir();
		m_FileName = m_File->getFileName();
		m_Sequence++;
		doSendInfo();
	} else 
		m_ExitNow = true;
	
}

void EvaAgentUploader::doErrorProcessing()
{
	if(m_Connecter){
		m_Connecter->close();
		delete m_Connecter;
		m_Connecter = NULL;
	}
	notifyNormalStatus(ESError);
	m_ExitNow = true;
}

void EvaAgentUploader::processAgentPacket( unsigned char * data, int len )
{
	unsigned short cmd = EvaUtil::read16(data + 5);
	switch(cmd){
	case QQ_FILE_AGENT_CMD_CREATE:
		processCreateReply(new EvaFTAgentCreateReply(data, len));
		break;
	case QQ_FILE_AGENT_CMD_TRANSFER:
		if(!m_IsSendingStart){
			processTransferStart(new EvaFTAgentTransferReply(QQ_FILE_AGENT_TRANSFER_START, data, len));
		}else{
			processTransferReply(new EvaFTAgentTransferReply(QQ_FILE_AGENT_TRANSFER_REPLY, data, len));
		}
		break;
	case QQ_FILE_AGENT_CMD_READY:
		processNotifyReady(new EvaFTAgentAskReady(data, len));
		break;
	case QQ_FILE_AGENT_CMD_START:
		processStartReply(new EvaFTAgentStartReply(data, len));
		break;
	}
}

void EvaAgentUploader::processCreateReply(EvaFTAgentCreateReply *packet)
{
	printf("EvaAgentUploader::processCreateReply\n");
	packet->setFileAgentKey(m_FileAgentKey);
	if(!packet->parse()){
		m_State = EError;
		delete packet;
		return;
	}
	switch(packet->getReplyCode()){
	case QQ_FILE_AGENT_CREATE_OK:{
		m_AgentSession = packet->getSessionId();
		m_ServerPort = packet->getPort();

		EvaFileNotifySessionEvent *event = new EvaFileNotifySessionEvent();
		event->setBuddyQQ(m_Id);
		event->setOldSession(m_Session);
		event->setNewSession(m_AgentSession);
		QApplication::postEvent(m_Receiver, event);
		m_State = ECreatingReady;
		}
		break;
	case QQ_FILE_AGENT_CREATE_REDIRECT:
		m_HostAddresses.clear();
		m_HostAddresses.append(QHostAddress(packet->getIp()));
		m_ServerPort = packet->getPort();
		m_State = EDnsReady;
		break;
	case QQ_FILE_AGENT_CREATE_ERROR:
		printf("EvaAgentUploader::processCreateReply -- :%s\n", packet->getMessage().c_str());
	default:
		m_State = EError;
	}
	delete packet;
}

void EvaAgentUploader::processNotifyReady(EvaFTAgentAskReady *packet) 
{
	packet->setFileAgentKey(m_FileAgentKey);
	if(!packet->parse()){
		m_State = EError;
		delete packet;
		return;
	}
	if(packet->isAskReady()){
		m_Sequence++;
		m_State = ENotifyReady;
	} else {
		m_State = EError;
	}
	delete packet;
}

void EvaAgentUploader::processStartReply(EvaFTAgentStartReply *packet)
{
	packet->setFileAgentKey(m_FileAgentKey);
	if(!packet->parse()){
		m_State = EError;
		delete packet;
		return;
	}
	m_State = ENone;
	delete packet;
}

void EvaAgentUploader::processTransferStart(EvaFTAgentTransferReply *packet)
{
	if(!packet->parse()){
		m_State = EError;
		delete packet;
		return;
	}
	m_BytesSent = packet->getStartPosition();
	m_State = ETransfer;
	m_IsSendingStart = true;
	m_StartTime = QDateTime::currentDateTime();
	notifyTransferStatus();
	delete packet;
}

void EvaAgentUploader::processTransferReply(EvaFTAgentTransferReply *packet)
{
	if(!packet->parse()){
		m_State = EError;
		delete packet;
		return;
	}

	if(packet->isReceivedOk()){
		notifyTransferStatus();
		if(m_BytesSent >= m_File->getFileSize())
			m_State = EFinished;
		else
			m_State = ETransfer;
		//printf("EvaAgentUploader::processTransferReply ---- m_State: %d\n", m_State);
	} else {
		printf("EvaAgentUploader::processTransferReply ---- isReceivedOk -- false \n");
		m_State = EError;
	}
	delete packet;
}



/** ================================================================== */

EvaAgentDownloader::EvaAgentDownloader(QObject *receiver, const int id, const QValueList<QString> &dirList,
			const QValueList<QString> &filenameList, 
			QValueList<unsigned int> sizeList)
	: EvaAgentThread(receiver, id, dirList, filenameList, sizeList, false),
	m_IsRecovery(false), m_MaxBufferSize(EVA_FILE_BUFFER_UNIT), 
	m_BufferSize(0), m_IsSendingStart(false)
{
	m_Sequence = 0x0008;// give it a random number anyway
	m_MaxBufferSize = 50 * EVA_FILE_BUFFER_UNIT; // default is 100K
}

EvaAgentDownloader::~EvaAgentDownloader()
{
	m_ItemBuffer.clear();
}

void EvaAgentDownloader::run()
{
	m_State = EDnsReady;
	while(!m_ExitNow){
		switch(m_State){
		case ENone:
			break;
		case EDnsReady:
			doCreateConnection();
			break;
		case ENetworkReady:
			doLoginRequest();
			break;
		case ENotifyReady:
			doReadyReply();
			break;
		case EInfoReady:
			doStartRequest(); // send info reply as well
			break;
		case EDataReply:
			doDataReply();
			break;
		case EFinished:
			doFinishProcessing();
			break;
		case EError:
			doErrorProcessing();
			break;
		default:
			break;
		}
		msleep( 200 );
	}
}

void EvaAgentDownloader::doLoginRequest()
{
	EvaFTAgentLogin *packet = new EvaFTAgentLogin();
	packet->setFileAgentToken(m_Token, m_TokenLength);
	send(packet);
	m_State = ENone;
}

void EvaAgentDownloader::doReadyReply( )
{
	send(new EvaFTAgentAckReady());
	m_State = ENone;
}

void EvaAgentDownloader::doStartRequest()
{
	send(new EvaFTAgentStart());
	EvaFTAgentTransfer *packet = new EvaFTAgentTransfer(QQ_FILE_AGENT_TRANSFER_START);
	packet->setOffset(m_StartOffset);
	send(packet);
	m_State = ENone;
}

void EvaAgentDownloader::doDataReply()
{
	m_Sequence++;
	send(new EvaFTAgentTransfer(QQ_FILE_AGENT_TRANSFER_REPLY));
	m_State = ENone;
}

void EvaAgentDownloader::doFinishProcessing()
{
	notifyTransferStatus();
	notifyNormalStatus(ESReceiveFinished);

// 	m_File = m_FileList.next();
// 	if(m_FileList.remove()){
// 		m_File = m_FileList.first();
// 		if(!m_File)
// 			m_ExitNow = true;
// 		m_Dir = m_File->getDir();
// 		m_FileName = m_File->getFileName();
// 		m_State = EInfoReady;
// 	} else 
// 		m_ExitNow = true;
	m_IsRecovery = false;
	m_StartOffset = 0;
	m_BufferSize = 0;
	m_BytesSent = 0;
	m_FileSize = 0;
	m_IsSendingStart = false;
	m_ItemBuffer.clear();
	m_StartTime = QDateTime::currentDateTime();
	//notifyTransferStatus();
	m_State = ENone;
}

void EvaAgentDownloader::doErrorProcessing()
{
	if(m_Connecter){
		m_Connecter->close();
		delete m_Connecter;
		m_Connecter=NULL;
	}
	notifyNormalStatus(ESError);
	m_ExitNow = true;
}


void EvaAgentDownloader::processAgentPacket( unsigned char * data, int len )
{
	unsigned short cmd = EvaUtil::read16(data + 5);

	switch(cmd){
	case QQ_FILE_AGENT_CMD_LOGIN:
		processLoginReply(new EvaFTAgentLoginReply(data, len));
		break;
	case QQ_FILE_AGENT_CMD_TRANSFER:{
		//unsigned short seq = EvaUtil::read16(data + 7);
		if(!m_IsSendingStart){
			processTransferInfo(new EvaFTAgentTransferReply(QQ_FILE_AGENT_TRANSFER_INFO, data, len));
		}else{
			processTransferData(new EvaFTAgentTransferReply(QQ_FILE_AGENT_TRANSFER_DATA, data, len));
		}
		}
		break;
	case QQ_FILE_AGENT_CMD_READY:
		processNotifyReady(new EvaFTAgentAskReady(data, len));
		break;
	case QQ_FILE_AGENT_CMD_START:
		processStartReply(new EvaFTAgentStartReply(data, len));
		break;
	}
}

void EvaAgentDownloader::processLoginReply( EvaFTAgentLoginReply  *packet)
{
	if(!parsePacket(packet)){
		m_State = EError;
		delete packet;
		return;
	}
	if(packet->isConnected()) m_State = ENone;
	else  m_State = EError;
	m_Sequence++;
	delete packet;
}

void EvaAgentDownloader::processNotifyReady( EvaFTAgentAskReady * packet )
{
	if(!parsePacket(packet)){
		m_State = EError;
		delete packet;
		return;
	}