mirror of
https://gitee.com/drabel/LibQQt.git
synced 2025-01-04 10:18:44 +08:00
1025 lines
27 KiB
C++
1025 lines
27 KiB
C++
#include "qqtcloudprotocol.h"
|
||
#include "qqtversion.h"
|
||
#include "qqtcore.h"
|
||
#include "qqt-qt.h"
|
||
|
||
QQtSocketTcpClient* QQTUpgradeClientInstance ( QObject* parent )
|
||
{
|
||
static QQtSocketTcpClient* cli = NULL;
|
||
|
||
if ( !cli )
|
||
{
|
||
QStringList ip;
|
||
ip << "222.175.114.244" << "124.133.1.54";
|
||
//"www.QQToo.com"
|
||
cli = new QQtSocketTcpClient ( parent );
|
||
cli->SetServerIPAddress ( ip );
|
||
cli->SetServerPort ( 8089 );
|
||
}
|
||
|
||
return cli;
|
||
}
|
||
|
||
QQtSocketTcpClient* QQTCloudClientInstance ( QObject* parent )
|
||
{
|
||
static QQtSocketTcpClient* cli = NULL;
|
||
|
||
if ( !cli )
|
||
{
|
||
QStringList ip;
|
||
ip << "222.175.114.244" << "124.133.1.54";
|
||
cli = new QQtSocketTcpClient ( parent );
|
||
cli->SetServerIPAddress ( ip );
|
||
cli->SetServerPort ( 7079 );
|
||
}
|
||
|
||
return cli;
|
||
}
|
||
|
||
|
||
QQTCloudProtocol::QQTCloudProtocol ( QObject* parent ) : QQtProtocol ( parent )
|
||
{
|
||
m_isLogined = false;
|
||
m_heartCount = 0;
|
||
m_UID = 0;
|
||
timer = new QTimer ( this );
|
||
timer->setSingleShot ( false );
|
||
connect ( timer, SIGNAL ( timeout() ), this, SLOT ( sendHeatBeatMessage() ) );
|
||
|
||
connect ( this, SIGNAL ( signalSendData() ), this, SLOT ( sendUploadFileData() ), Qt::QueuedConnection );
|
||
connect ( this, SIGNAL ( signalDownData() ), this, SLOT ( sendDownFileData() ), Qt::QueuedConnection );
|
||
connect ( this, SIGNAL ( signalDownSucc() ), this, SLOT ( sendDownFileSuccess() ), Qt::QueuedConnection );
|
||
|
||
|
||
}
|
||
|
||
QTCheckVersionResult& QQTCloudProtocol::GetVersionResult() { return m_versionresult; }
|
||
|
||
QTCloudListDirResult& QQTCloudProtocol::GetDirList() { return m_dirs; }
|
||
|
||
QTCloudListFileResult& QQTCloudProtocol::GetListedFiles() { return m_files; }
|
||
|
||
bool QQTCloudProtocol::isLogined() { return m_isLogined; }
|
||
|
||
void QQTCloudProtocol::startHeartBeat()
|
||
{
|
||
m_heartCount = 0;
|
||
/*
|
||
* TODO:心跳检测重连会不会引发这条消息？
|
||
* 如果连接还未成功开始发送心跳包，
|
||
* QNativeSocketEngine::write() was not called in QAbstractSocket::ConnectedState
|
||
*/
|
||
timer->start ( 30 * 1000 );
|
||
}
|
||
|
||
void QQTCloudProtocol::stopHeartBeat()
|
||
{
|
||
m_heartCount = MAX_HEARDBEAT + 1;
|
||
timer->stop();
|
||
}
|
||
|
||
void QQTCloudProtocol::sendMessage ( quint16 cmd, QByteArray& data )
|
||
{
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( cmd );
|
||
qMsg.setData ( data );
|
||
qMsg.translate();
|
||
//pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
}
|
||
|
||
bool QQTCloudProtocol::dispatcher ( const QByteArray& m )
|
||
{
|
||
bool ret = true;
|
||
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.parser ( m );
|
||
//pline() << qMsg;
|
||
|
||
switch ( qMsg.cmd() )
|
||
{
|
||
case _TCPCMD_LOGINRESUALT:
|
||
recvLoginResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_HEARTBEATRESP:
|
||
recvHeatBeatResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_CHECKVERSIONRSP:
|
||
recvCheckVersionResult ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEDIRLIST:
|
||
recvListDirResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEADDRESUALT:
|
||
recvAddDirResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEALTERRESUALT:
|
||
recvModDirResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEDELETERESUALT:
|
||
recvDelDirResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEFILELIST:
|
||
recvListFilesResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEPUBLICDIRLIST:
|
||
recvListPubDirResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEPUBLICFILELIST:
|
||
recvListPubFilesResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEFILEINFO:
|
||
recvDownFileResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVEFILEDATA:
|
||
recvDownFileDataResultMessage ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVECOMFIREFILEINFO:
|
||
recvUploadFileResult ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVECOMFIREFILEDATA:
|
||
recvUploadFileDataResult ( qMsg );
|
||
break;
|
||
|
||
case _TCPCMD_RECEIVECOMFIREFILE:
|
||
recvUploadFileSuccess ( qMsg );
|
||
break;
|
||
|
||
default:
|
||
//pline() << "receive unknown command:" << hex << qMsg.cmd();
|
||
ret = false;
|
||
break;
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
void QQTCloudProtocol::sendHeatBeatMessage()
|
||
{
|
||
/*
|
||
* 断链判断 如果断链 TODO:
|
||
*/
|
||
if ( m_heartCount > MAX_HEARDBEAT )
|
||
{
|
||
#if 1
|
||
/*
|
||
* 重连策略 30 * 2 s
|
||
*/
|
||
static int curp = 0;
|
||
|
||
if ( curp >= 2 )
|
||
{
|
||
curp = 0;
|
||
emit signalReconnectQequest();
|
||
return;
|
||
}
|
||
|
||
curp++;
|
||
#else
|
||
/*
|
||
* 此处设置重连策略 30s 150s 300s 600s
|
||
*/
|
||
static int p[4] = {1, 5, 10, 20};
|
||
static int curp = 0;
|
||
static int curpos = 0;
|
||
|
||
if ( curp >= p[curpos] )
|
||
{
|
||
curp = 0;
|
||
curpos = ( curpos + 1 ) % 4;
|
||
connectToSingelHost();
|
||
return;
|
||
}
|
||
|
||
curp++;
|
||
#endif
|
||
return;
|
||
}
|
||
|
||
pline() << "HeartBeat Count:" << m_heartCount;
|
||
m_heartCount++;
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( _TCPCMD_HEART );
|
||
qMsg.translate();
|
||
pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
//waitForBytesWritten();
|
||
}
|
||
|
||
void QQTCloudProtocol::sendLoginMessage()
|
||
{
|
||
/*
|
||
* 这个地方可能要改动，串口发过来的时字符串，不是hex
|
||
*/
|
||
QSettings set;
|
||
QByteArray _name = set.value ( "Device/DeviceNo" ).toByteArray();
|
||
QByteArray _pwd = set.value ( "Device/Password" ).toByteArray();
|
||
|
||
QString name, pwd;
|
||
|
||
for ( int i = 0; i < _name.size(); i++ )
|
||
name += QString::number ( ( quint8 ) _name[i], 16 );
|
||
|
||
for ( int i = 0; i < _pwd.size(); i++ )
|
||
pwd += QString::number ( ( quint8 ) _pwd[i], 16 );
|
||
|
||
name = name.toUpper();
|
||
pwd = pwd.toUpper();
|
||
|
||
m_isLogined = false;
|
||
QTCloudLogin t;
|
||
t.m_name = name;
|
||
t.m_password = pwd;
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( _TCPCMD_LOGIN );
|
||
QByteArray d;
|
||
packLoginData ( d, t );
|
||
qMsg.setData ( d );
|
||
qMsg.translate();
|
||
//pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendLogoutMessage()
|
||
{
|
||
m_isLogined = false;
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( _TCPCMD_EXIT );
|
||
qMsg.translate();
|
||
//pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
}
|
||
|
||
void QQTCloudProtocol::recvConnPoolFullMessage ( QQTNetworkMessage& ) {}
|
||
|
||
|
||
void QQTCloudProtocol::recvLoginResultMessage ( QQTNetworkMessage& qMsg )
|
||
{
|
||
m_UID = qMsg.uid();
|
||
QTCloudLoginResult qtLoginResult;
|
||
parseLoginResultData ( qtLoginResult, qMsg.data() );
|
||
|
||
switch ( qtLoginResult.m_result )
|
||
{
|
||
case 0x00:
|
||
{
|
||
pline() << "Login success id:" << hex << m_UID;
|
||
m_isLogined = true;
|
||
emit signalLoginSucc();
|
||
}
|
||
break;
|
||
|
||
case 0x10:
|
||
pline() << "Other user logined";
|
||
break;
|
||
|
||
case 0x11:
|
||
pline() << "User unexisted";
|
||
break;
|
||
|
||
case 0x12:
|
||
pline() << "Password error upflowed";
|
||
break;
|
||
|
||
case 0x23:
|
||
case 0x22:
|
||
case 0x21:
|
||
pline() << "Password error" << hex << qtLoginResult.m_result;
|
||
break;
|
||
|
||
case 0xFF:
|
||
default:
|
||
pline() << "unknown error" << qtLoginResult.m_result;
|
||
break;
|
||
}
|
||
|
||
if ( 0x00 != qtLoginResult.m_result )
|
||
emit signalLoginFail();
|
||
}
|
||
|
||
void QQTCloudProtocol::recvHeatBeatResultMessage ( QQTNetworkMessage& )
|
||
{
|
||
m_heartCount = 0;
|
||
pline() << "HeartBeat Callback";
|
||
}
|
||
|
||
|
||
void QQTCloudProtocol::packCheckVersionData ( QByteArray& l, const QTCheckVersion& t )
|
||
{
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_SOFTWAREID, t.m_softwareid );
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_DEVICECODE, t.m_devicecode );
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_SOFTWARECODE, t.m_softwarecode );
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_VERSION, t.m_version );
|
||
}
|
||
|
||
void QQTCloudProtocol::parseCheckVersionResultData ( QTCheckVersionResult& t, const QByteArray& l )
|
||
{
|
||
quint32 pos = 0;
|
||
QByteArray b = l;
|
||
t.m_softwareid = parseKeyWordInByteArray ( b, _TCP_SECTION_SOFTWAREID, pos );
|
||
t.m_devicecode = parseKeyWordInByteArray ( b, _TCP_SECTION_DEVICECODE, pos );
|
||
t.m_softwarecode = parseKeyWordInByteArray ( b, _TCP_SECTION_SOFTWARECODE, pos );
|
||
t.m_version = parseKeyWordInByteArray ( b, _TCP_SECTION_VERSION, pos );
|
||
t.m_NewSoftwareID = parseKeyWordInByteArray ( b, _TCP_SECTION_NEWSOFTWAREID, pos );
|
||
|
||
/*
|
||
* 和公共文件区域的一样，郑工服务器端按照
|
||
*/
|
||
QByteArray m_Explain = parseKeyWordInByteArray ( b, _TCP_SECTION_EXPLAIN, pos );
|
||
QTextCodec* Codec = QTextCodec::codecForName ( "gbk" );
|
||
t.m_Explain = Codec->toUnicode ( m_Explain );
|
||
|
||
t.m_ReleaseStatus = parseKeyWordInByteArray ( b, _TCP_SECTION_RELEASESTAT, pos );
|
||
t.m_ReleaseDate = parseKeyWordInByteArray ( b, _TCP_SECTION_RELEASEDATE, pos );
|
||
t.m_FileName = parseKeyWordInByteArray ( b, _TCP_SECTION_FILENAME, pos );
|
||
t.m_FileMD5 = parseKeyWordInByteArray ( b, _TCP_SECTION_FILEMD5, pos );
|
||
t.m_FileSize = parseKeyWordInByteArray ( b, _TCP_SECTION_FILESIZE, pos );
|
||
}
|
||
|
||
|
||
void QQTCloudProtocol::sendCheckVersion()
|
||
{
|
||
QTCheckVersion t;
|
||
t.m_softwareid = "0";
|
||
t.m_devicecode = "0601";
|
||
t.m_softwarecode = "211100";
|
||
t.m_version = "";
|
||
quint16 _tcpcmd = _TCPCMD_CHECKVERSION;
|
||
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( _tcpcmd );
|
||
QByteArray d;
|
||
packCheckVersionData ( d, t );
|
||
qMsg.setData ( d );
|
||
qMsg.translate();
|
||
//pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendCheckNewVersion()
|
||
{
|
||
QTCheckVersion t;
|
||
t.m_softwareid = m_versionresult.m_NewSoftwareID;
|
||
t.m_devicecode = "";
|
||
t.m_softwarecode = "";
|
||
t.m_version = "";
|
||
quint16 _tcpcmd = _TCPCMD_CHECKVERSION;
|
||
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( _tcpcmd );
|
||
QByteArray d;
|
||
packCheckVersionData ( d, t );
|
||
qMsg.setData ( d );
|
||
qMsg.translate();
|
||
//pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
}
|
||
|
||
void QQTCloudProtocol::recvCheckVersionResult ( QQTNetworkMessage& qMsg )
|
||
{
|
||
parseCheckVersionResultData ( m_versionresult, qMsg.data() );
|
||
emit signalCheckVersionResult();
|
||
}
|
||
|
||
|
||
void QQTCloudProtocol::packListDirData ( QByteArray& l, const QTCloudListDir& t )
|
||
{
|
||
l = t.m_code.toLatin1();
|
||
}
|
||
|
||
void QQTCloudProtocol::parseListDirResultData ( QTCloudListDirResult& r, const QByteArray& l )
|
||
{
|
||
quint32 pos = 0;
|
||
QByteArray b = l;
|
||
QByteArray h;
|
||
h = parseKeyWordInByteArray ( b, _TCP_SECTION_UPCODE, pos );
|
||
r.m_upcode = h;
|
||
|
||
while ( pos < b.length() )
|
||
{
|
||
_QTCloudListDirResult _r;
|
||
QByteArray __r;
|
||
__r = parseKeyWordInByteArray ( b, _TCP_SECTION_ID, pos );
|
||
_r.m_id = __r;
|
||
__r = parseKeyWordInByteArray ( b, _TCP_SECTION_CODE, pos );
|
||
_r.m_code = __r;
|
||
__r = parseKeyWordInByteArray ( b, _TCP_SECTION_NAME, pos );
|
||
_r.m_name = __r;
|
||
r.m_dir.push_back ( _r );
|
||
}
|
||
}
|
||
|
||
void QQTCloudProtocol::packAddDirData ( QByteArray& l, const QTCloudAddDir& t )
|
||
{
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_UPCODE, t.m_upcode );
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_CODE, t.m_code );
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_NAME, t.m_name );
|
||
}
|
||
|
||
void QQTCloudProtocol::parseAddDirResultData ( QTCloudAddDirResult& t, const QByteArray& l )
|
||
{
|
||
quint32 pos = 0;
|
||
QByteArray b = l;
|
||
t.m_upcode = parseKeyWordInByteArray ( b, _TCP_SECTION_UPCODE, pos );
|
||
t.m_result = parseKeyWordInByteArray ( b, _TCP_SECTION_RESULE, pos );
|
||
}
|
||
|
||
void QQTCloudProtocol::packDelFileData ( QByteArray& l, const QTCloudDelFile& t )
|
||
{
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_CODE, t.m_code );
|
||
packKeyWordToByteArray ( l, _TCP_SECTION_ID, t.m_id );
|
||
}
|
||
|
||
void QQTCloudProtocol::parseListFileResultData ( QTCloudListFileResult& r, const QByteArray& l )
|
||
{
|
||
quint32 pos = 0;
|
||
QByteArray b = l;
|
||
QByteArray h;
|
||
h = parseKeyWordInByteArray ( b, _TCP_SECTION_CODE, pos );
|
||
r.m_code = h;
|
||
|
||
while ( pos < b.length() )
|
||
{
|
||
_QTCloudListFileResult _r;
|
||
QByteArray __r;
|
||
__r = parseKeyWordInByteArray ( b, _TCP_SECTION_ID, pos );
|
||
_r.m_id = __r;
|
||
__r = parseKeyWordInByteArray ( b, _TCP_SECTION_NAME, pos );
|
||
_r.m_name = __r;
|
||
__r = parseKeyWordInByteArray ( b, _TCP_SECTION_SIZE, pos );
|
||
_r.m_size = __r;
|
||
__r = parseKeyWordInByteArray ( b, _TCP_SECTION_DATE, pos );
|
||
_r.m_date = __r;
|
||
r.m_file.push_back ( _r );
|
||
}
|
||
}
|
||
|
||
void QQTCloudProtocol::packDownDevFileData ( QByteArray& l, const QTCloudDownDevFile& t )
|
||
{
|
||
l = t.m_id.toLatin1();
|
||
}
|
||
|
||
void QQTCloudProtocol::parseDownDevFileResultData ( QTCloudDownDevFileResult& t, const QByteArray& l )
|
||
{
|
||
quint32 pos = 0;
|
||
QByteArray b = l;
|
||
t.m_fileno = parseKeyWordInByteArray ( b, _TCP_SECTION_FILENO, pos );
|
||
t.m_name = parseKeyWordInByteArray ( b, _TCP_SECTION_NAME, pos );
|
||
t.m_length = parseKeyWordInByteArray ( b, _TCP_SECTION_LENGTH, pos );
|
||
}
|
||
|
||
void QQTCloudProtocol::packDownDevFileSuccessData ( QByteArray& l, const QTCloudDownFileSuccess& t )
|
||
{
|
||
l << t.m_fileno;
|
||
}
|
||
|
||
void QQTCloudProtocol::packDownDevFileDataData ( QByteArray& l, const QTCloudDownFileData& t )
|
||
{
|
||
l << t.m_fileno << t.m_dno;
|
||
}
|
||
|
||
void QQTCloudProtocol::parseDownDevFileDataResultData ( QTCloudDownFileDataResult& t, const QByteArray& l )
|
||
{
|
||
quint32 pos = 0;
|
||
QByteArray b = l;
|
||
b >> t.m_fileno >> t.m_dno >> t.m_addr >> t.m_dlen;
|
||
t.m_data.resize ( t.m_dlen );
|
||
b >> t.m_data;
|
||
}
|
||
|
||
void QQTCloudProtocol::packUploadFileData ( QByteArray& l, const QTCloudUploadFile& t )
|
||
{
|
||
l = QString ( _TCPCMD_DATASENDFILEINFO ).arg ( t.m_code ).arg ( t.m_name ).arg ( t.m_overwrite ).arg (
|
||
t.m_length ).toLatin1();
|
||
}
|
||
|
||
void QQTCloudProtocol::parseUploadFileResultData ( QTCloudUploadFileResult& t, const QByteArray& l )
|
||
{
|
||
QByteArray b = l;
|
||
b >> t.m_fileno >> t.m_state;
|
||
}
|
||
|
||
void QQTCloudProtocol::packUploadFileDataData ( QByteArray& l, const QTCloudUploadFileData& t )
|
||
{
|
||
l << t.m_fileno << t.m_dno << t.m_addr << t.m_dlen << t.m_data;
|
||
}
|
||
|
||
void QQTCloudProtocol::parseUploadFileDataResultData ( QTCloudUploadFileDataResult& t, const QByteArray& l )
|
||
{
|
||
QByteArray b = l;
|
||
b >> t.m_fileno >> t.m_dno;
|
||
}
|
||
|
||
void QQTCloudProtocol::parseUploadFileSuccessData ( QTCloudUploadFileSuccess& t, const QByteArray& l )
|
||
{
|
||
QByteArray b = l;
|
||
b >> t.m_fileno;
|
||
}
|
||
|
||
|
||
void QQTCloudProtocol::sendListDirectory ( QString code )
|
||
{
|
||
QTCloudListDir t;
|
||
t.m_code = code;
|
||
quint16 _tcpcmd = _TCPCMD_SEARCHDIR;
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( _tcpcmd );
|
||
QByteArray d;
|
||
packListDirData ( d, t );
|
||
qMsg.setData ( d );
|
||
qMsg.translate();
|
||
//pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendAddDirectory()
|
||
{
|
||
QTCloudAddDir t;
|
||
t.m_upcode = "";
|
||
t.m_code = "";
|
||
t.m_name = "Method2";
|
||
quint16 _tcpcmd = _TCPCMD_ADDDIR;
|
||
QByteArray d;
|
||
packAddDirData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendModDirectory()
|
||
{
|
||
QTCloudModDirName t;
|
||
t.m_upcode = "";
|
||
t.m_code = "";
|
||
t.m_name = "Method2";
|
||
quint16 _tcpcmd = _TCPCMD_ALTERDIR;
|
||
|
||
QByteArray d;
|
||
//(d, t);
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendDelDirectory()
|
||
{
|
||
QTCloudDelDir t;
|
||
t.m_upcode = "";
|
||
t.m_code = "";
|
||
t.m_name = "Method2";
|
||
quint16 _tcpcmd = _TCPCMD_DELETEDIR;
|
||
QByteArray d;
|
||
//(d, t);
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::recvAddDirResultMessage ( QQTNetworkMessage& ) {}
|
||
|
||
void QQTCloudProtocol::recvDelDirResultMessage ( QQTNetworkMessage& ) {}
|
||
|
||
void QQTCloudProtocol::recvModDirResultMessage ( QQTNetworkMessage& ) {}
|
||
|
||
void QQTCloudProtocol::sendListFiles ( QString code )
|
||
{
|
||
QTCloudListFile t;
|
||
t.m_code = code;
|
||
quint16 _tcpcmd = _TCPCMD_SEARCHFILE;
|
||
QByteArray d;
|
||
packListDirData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendDelFile ( QString code, QString id )
|
||
{
|
||
QTCloudDelFile t;
|
||
t.m_code = code;
|
||
t.m_id = id;
|
||
quint16 _tcpcmd = _TCPCMD_DELETEFILE;
|
||
QByteArray d;
|
||
packDelFileData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
pline() << t.m_code << t.m_id;
|
||
}
|
||
|
||
void QQTCloudProtocol::sendListPubDirectory()
|
||
{
|
||
QTCloudListPubDir t;
|
||
t.m_code = "";
|
||
quint16 _tcpcmd = _TCPCMD_SEARCHPUBLICDIR;
|
||
QByteArray d;
|
||
packListDirData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendListPubFiles()
|
||
{
|
||
QTCloudListPubFile t;
|
||
t.m_code = "";
|
||
quint16 _tcpcmd = _TCPCMD_SEARCHPUBLICFILE;
|
||
QByteArray d;
|
||
packListDirData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendDownDevFiles ( const QString& id, const QString& localfile )
|
||
{
|
||
m_downfileresult.m_localfile = localfile;
|
||
m_work = 1;
|
||
QTCloudDownDevFile t;
|
||
t.m_id = id;
|
||
quint16 _tcpcmd = _TCPCMD_DOWNLOADFILE;
|
||
QByteArray d;
|
||
packDownDevFileData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendDownPubFiles()
|
||
{
|
||
QTCloudDownPubFile t;
|
||
_QTCloudListFileResult _result;
|
||
|
||
foreach ( _result, m_pubfiles.m_file )
|
||
{
|
||
break;
|
||
}
|
||
|
||
t.m_id = _result.m_id;
|
||
quint16 _tcpcmd = _TCPCMD_DOWNLOADPUBFILE;
|
||
QByteArray d;
|
||
packDownDevFileData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendDownFileData()
|
||
{
|
||
pline() << m_downfiledata.m_fileno << m_downfiledata.m_dno;
|
||
quint16 _tcpcmd = _TCPCMD_COMFIREFILEINFO;
|
||
QByteArray d;
|
||
packDownDevFileDataData ( d, m_downfiledata );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendCancelDown()
|
||
{
|
||
QTCloudCancelDownFile t;
|
||
t.m_fileno = m_downfiledata.m_fileno;
|
||
quint16 _tcpcmd = _TCPCMD_CANCELREVFILE;
|
||
m_work = 0;
|
||
emit signalCancelDown();;
|
||
QByteArray d;
|
||
packDownDevFileSuccessData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendDownFileSuccess()
|
||
{
|
||
QTCloudDownFileSuccess t;
|
||
t.m_fileno = m_downfiledata.m_fileno;
|
||
quint16 _tcpcmd = _TCPCMD_DOWNFILEOK;
|
||
QByteArray d;
|
||
packDownDevFileSuccessData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::sendUploadFile ( const QString& code, const QString& cloudname, const QString& localfile )
|
||
{
|
||
m_uploadfile.m_code = code;
|
||
m_uploadfile.m_name = cloudname;
|
||
m_uploadfile.m_localfile = localfile;
|
||
QFileInfo f ( m_uploadfile.m_localfile );
|
||
m_uploadfile.m_length = QString::number ( f.size() );
|
||
m_uploadfile.m_overwrite = _TCP_RESULT_TRUE;
|
||
quint16 _tcpcmd = _TCPCMD_SENDFILEINFO;
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( _tcpcmd );
|
||
QByteArray d;
|
||
packUploadFileData ( d, m_uploadfile );
|
||
qMsg.setData ( d );
|
||
qMsg.translate();
|
||
//pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
//waitForBytesWritten(-1);
|
||
}
|
||
|
||
void QQTCloudProtocol::sendUploadFileData()
|
||
{
|
||
m_uploadfiledata.m_addr = m_uploadfiledata.m_dno * _TCP_BLOCKDATA_SIZE;
|
||
QFile f ( m_uploadfile.m_localfile );
|
||
f.open ( QIODevice::ReadOnly );
|
||
|
||
if ( f.isOpen() )
|
||
{
|
||
f.seek ( m_uploadfiledata.m_addr );
|
||
m_uploadfiledata.m_data = f.read ( _TCP_BLOCKDATA_SIZE );
|
||
}
|
||
|
||
f.close();
|
||
m_uploadfiledata.m_dlen = m_uploadfiledata.m_data.length();
|
||
quint16 _tcpcmd = _TCPCMD_SENDFILEDATA;
|
||
QQTNetworkMessage qMsg;
|
||
qMsg.setUid ( m_UID );
|
||
qMsg.setCmd ( _tcpcmd );
|
||
QByteArray d;
|
||
packUploadFileDataData ( d, m_uploadfiledata );
|
||
qMsg.setData ( d );
|
||
qMsg.translate();
|
||
pline() << qMsg;
|
||
QByteArray b;
|
||
qMsg.packer ( b );
|
||
write ( b );
|
||
|
||
pline() << m_uploadfile.m_name << m_uploadfile.m_localfile << m_uploadfiledata.m_fileno << m_uploadfiledata.m_dno <<
|
||
m_uploadfiledata.m_addr << m_uploadfiledata.m_dlen;
|
||
}
|
||
|
||
void QQTCloudProtocol::sendCancelUpload()
|
||
{
|
||
QTCloudCancelUploadFile t;
|
||
t.m_fileno = m_uploadfiledata.m_fileno;
|
||
quint16 _tcpcmd = _TCPCMD_CANCELSENDFILE;
|
||
QByteArray d;
|
||
packDownDevFileSuccessData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
emit signalCancelUpload();
|
||
}
|
||
|
||
void QQTCloudProtocol::sendDownUpgradeFile ( const QString& id, const QString& localfile )
|
||
{
|
||
m_downfileresult.m_localfile = localfile;
|
||
m_work = 1;
|
||
QTCloudDownDevFile t;
|
||
t.m_id = id;
|
||
quint16 _tcpcmd = _TCPCMD_DOWNUPGRADEFILE;
|
||
QByteArray d;
|
||
packDownDevFileData ( d, t );
|
||
sendMessage ( _tcpcmd, d );
|
||
}
|
||
|
||
void QQTCloudProtocol::recvListDirResultMessage ( QQTNetworkMessage& qMsg )
|
||
{
|
||
m_dirs.m_upcode = "";
|
||
m_dirs.m_dir.clear();
|
||
parseListDirResultData ( m_dirs, qMsg.data() );
|
||
pline() << m_dirs.m_upcode;
|
||
_QTCloudListDirResult _result;
|
||
|
||
foreach ( _result, m_dirs.m_dir )
|
||
{
|
||
/*
|
||
* 这里保存到model中
|
||
*/
|
||
pline() << _result.m_id << _result.m_code << _result.m_name;
|
||
}
|
||
|
||
emit signalListDirOK();
|
||
}
|
||
|
||
void QQTCloudProtocol::recvListFilesResultMessage ( QQTNetworkMessage& qMsg )
|
||
{
|
||
m_files.m_code = "";
|
||
m_files.m_file.clear();
|
||
parseListFileResultData ( m_files, qMsg.data() );
|
||
pline() << m_files.m_code;
|
||
_QTCloudListFileResult _result;
|
||
|
||
foreach ( _result, m_files.m_file )
|
||
{
|
||
/*
|
||
* 这里保存到model中
|
||
*/
|
||
pline() << _result.m_id << _result.m_name << _result.m_size << _result.m_date;
|
||
}
|
||
|
||
emit signalListFileOK();
|
||
}
|
||
|
||
void QQTCloudProtocol::recvListPubDirResultMessage ( QQTNetworkMessage& qMsg )
|
||
{
|
||
m_pubdirs.m_upcode = "";
|
||
m_pubdirs.m_dir.clear();
|
||
parseListDirResultData ( m_pubdirs, qMsg.data() );
|
||
pline() << m_pubdirs.m_upcode;
|
||
_QTCloudListDirResult _result;
|
||
|
||
foreach ( _result, m_pubdirs.m_dir )
|
||
{
|
||
/*
|
||
* 这里保存到model中
|
||
*/
|
||
pline() << _result.m_id << _result.m_code << _result.m_name;
|
||
}
|
||
}
|
||
|
||
void QQTCloudProtocol::recvListPubFilesResultMessage ( QQTNetworkMessage& qMsg )
|
||
{
|
||
m_pubfiles.m_code = "";
|
||
m_pubfiles.m_file.clear();
|
||
parseListFileResultData ( m_pubfiles, qMsg.data() );
|
||
pline() << m_pubfiles.m_code;
|
||
_QTCloudListFileResult _result;
|
||
|
||
foreach ( _result, m_pubfiles.m_file )
|
||
{
|
||
/*
|
||
* 这里保存到model中
|
||
*/
|
||
pline() << _result.m_id << _result.m_name << _result.m_size << _result.m_date;
|
||
}
|
||
}
|
||
|
||
void QQTCloudProtocol::recvDownFileResultMessage ( QQTNetworkMessage& qMsg )
|
||
{
|
||
parseDownDevFileResultData ( m_downfileresult, qMsg.data() );
|
||
pline() << m_downfileresult.m_fileno << m_downfileresult.m_name << m_downfileresult.m_length;
|
||
m_downfiledata.m_fileno = m_downfileresult.m_fileno.toInt();
|
||
|
||
QString tmpFile = m_downfileresult.m_localfile;
|
||
|
||
#ifdef __EMBEDDED_LINUX__
|
||
system ( QString ( "touch %1" ).arg ( tmpFile ).toLatin1().data() );
|
||
#endif
|
||
|
||
QFile f ( tmpFile );
|
||
f.open ( QIODevice::WriteOnly | QIODevice::Truncate );
|
||
pline() << tmpFile << f.size();
|
||
f.close();
|
||
emit signalUpdateProgress ( 0 );
|
||
emit signalDownData();
|
||
}
|
||
|
||
void QQTCloudProtocol::recvDownFileDataResultMessage ( QQTNetworkMessage& qMsg )
|
||
{
|
||
if ( 0 == m_work )
|
||
return;
|
||
|
||
QTCloudDownFileDataResult result;
|
||
parseDownDevFileDataResultData ( result, qMsg.data() );
|
||
pline() << result.m_fileno << result.m_dno << result.m_addr <<
|
||
result.m_dlen;// << m_downfiledata.m_data;
|
||
int nFileSize = 0;
|
||
QString tmpFile = m_downfileresult.m_localfile;
|
||
QFile f ( tmpFile );
|
||
f.open ( QIODevice::WriteOnly | QIODevice::Append );
|
||
f.write ( result.m_data );
|
||
nFileSize = f.size();
|
||
f.close();
|
||
pline() << nFileSize << m_downfileresult.m_length;
|
||
int percent = 0;
|
||
|
||
if ( nFileSize > 0 )
|
||
percent = 100 * nFileSize / m_downfileresult.m_length.toInt();
|
||
|
||
emit signalUpdateProgress ( percent );
|
||
pline() << percent;
|
||
|
||
if ( nFileSize < m_downfileresult.m_length.toInt() )
|
||
{
|
||
m_downfiledata.m_dno++;
|
||
emit signalDownData();
|
||
}
|
||
else
|
||
{
|
||
m_downfiledata.m_dno = 0;
|
||
emit signalDownSucc();
|
||
}
|
||
}
|
||
|
||
void QQTCloudProtocol::recvUploadFileResult ( QQTNetworkMessage& qMsg )
|
||
{
|
||
QTCloudUploadFileResult result;
|
||
parseUploadFileResultData ( result, qMsg.data() );
|
||
pline() << result.m_fileno << result.m_state;
|
||
perr ( result.m_state, 0x00 ) << "ok to send file data";
|
||
perr ( result.m_state, 0x01 ) << "unsupport file type";
|
||
perr ( result.m_state, 0x02 ) << "file too length";
|
||
perr ( result.m_state, 0x03 ) << "too much file";
|
||
perr ( result.m_state, 0x04 ) << "files too long";
|
||
perr ( result.m_state, 0x14 ) << "no much storage";
|
||
|
||
if ( result.m_state == 0x00 )
|
||
{
|
||
m_uploadfiledata.m_fileno = result.m_fileno;
|
||
m_uploadfiledata.m_dno = 0;
|
||
/*
|
||
* 使用Timer确认不是网络速率的原因。
|
||
*/
|
||
emit signalUpdateProgress ( 0 );
|
||
emit signalSendData();
|
||
}
|
||
}
|
||
|
||
void QQTCloudProtocol::recvUploadFileDataResult ( QQTNetworkMessage& qMsg )
|
||
{
|
||
QTCloudUploadFileDataResult result;
|
||
|
||
parseUploadFileDataResultData ( result, qMsg.data() );
|
||
pline() << result.m_fileno << result.m_dno << result.m_dno* _TCP_BLOCKDATA_SIZE << m_uploadfile.m_length.toInt();
|
||
|
||
/*
|
||
* 不需要发空串
|
||
*/
|
||
m_uploadfiledata.m_dno = result.m_dno + 1;
|
||
int percent = 0;
|
||
|
||
if ( m_uploadfile.m_length.toInt() > 0 )
|
||
percent = 100 * m_uploadfiledata.m_dno * _TCP_BLOCKDATA_SIZE /
|
||
m_uploadfile.m_length.toInt();
|
||
|
||
if ( m_uploadfiledata.m_dno * _TCP_BLOCKDATA_SIZE < m_uploadfile.m_length.toInt() )
|
||
{
|
||
emit signalSendData();
|
||
emit signalUpdateProgress ( percent );
|
||
}
|
||
}
|
||
|
||
void QQTCloudProtocol::recvUploadFileSuccess ( QQTNetworkMessage& qMsg )
|
||
{
|
||
QTCloudUploadFileSuccess result;
|
||
parseUploadFileSuccessData ( result, qMsg.data() );
|
||
pline() << result.m_fileno << m_uploadfiledata.m_dno << m_uploadfiledata.m_dno* _TCP_BLOCKDATA_SIZE <<
|
||
m_uploadfile.m_length.toInt() << "upload success";
|
||
emit signalUpdateProgress ( 100 );
|
||
emit signalUploadSucc();
|
||
}
|
||
|
||
void QQTCloudProtocol::packLoginData ( QByteArray& l, const QTCloudLogin& t )
|
||
{
|
||
l = QString ( _TCPCMD_DATALOGIN ).arg ( t.m_name ).arg ( t.m_password ).toLatin1();
|
||
}
|
||
|
||
void QQTCloudProtocol::parseLoginResultData ( QTCloudLoginResult& t, const QByteArray& l )
|
||
{
|
||
QByteArray _l = l;
|
||
_l >> t.m_result;
|
||
}
|
||
|
||
|
||
QByteArray& QQTCloudProtocol::packKeyWordToByteArray ( QByteArray& array, const QString& key, const QString& value )
|
||
{
|
||
return array << key.toLatin1() << "=\"" << value.toLatin1() << "\"";
|
||
}
|
||
|
||
QByteArray QQTCloudProtocol::parseKeyWordInByteArray ( const QByteArray& array, const QByteArray& section,
|
||
quint32& pos )
|
||
{
|
||
int index = pos, indexTemp = 0;
|
||
|
||
index = array.indexOf ( section, index );
|
||
index = array.indexOf ( '\"', index );
|
||
indexTemp = array.indexOf ( '\"', index + 1 );
|
||
pos = indexTemp + 1;
|
||
return array.mid ( index + 1, ( indexTemp - index - 1 ) );
|
||
}
|
||
|
||
quint16 QQTCloudProtocol::splitter ( const QByteArray& s )
|
||
{
|
||
QByteArray l = s.left ( 4 );
|
||
quint16 b0 = 0, b1 = 0;
|
||
l >> b0 >> b1;
|
||
return b1;
|
||
}
|
||
|
||
quint16 QQTCloudProtocol::minlength()
|
||
{
|
||
return 16;
|
||
}
|
||
|
||
quint16 QQTCloudProtocol::maxlength()
|
||
{
|
||
return 32768;
|
||
}
|