void PacketProcesser::processUserChangeStatus(InPacket *inPacket)
{
static short filter = 0; //用于过滤重复收到的包
short sequence = inPacket->getSequence();
if(filter == sequence)
{
delete inPacket;
return;
}
filter = sequence;
//删除重发队列中的包
wingApp->packetStorage->removeNeedAckPacketBySeq(sequence);
uint8 *bodyPtr = inPacket->getBody();
uint8 flag = bodyPtr[0];
if(flag == 0x30) //成功
{
//打印调试信息
DWHERE();
DPRINT("- - - > User change status succeed!");
}
else
{
//打印调试信息
DWHERE();
DPRINT("- - - > User change status failed!");
}
SAFE_DELETE(inPacket);
}
void PacketStorage::removeNeedAckPacketBySeq(unsigned short seq)
{
mutex.lock();
if(!needAckPacketList.isEmpty())
{
//打印调试信息
DWHERE();
DPRINT("- - - > needAckPacketList.size():%d",needAckPacketList.size());
OutPacket * outPacketPtr = NULL;
QHashIterator<short, OutPacket *> iter(needAckPacketList);
while(iter.hasNext())
{
iter.next();
if(iter.key() == seq)
{
outPacketPtr = iter.value();
needAckPacketList.remove(iter.key());
SAFE_DELETE(outPacketPtr);
//打印调试信息
DWHERE();
DPRINT("- - - > needAckPacketList.size():%d",needAckPacketList.size());
}
}
}
mutex.unlock();
}
void PacketStorage::removeOutPacketByCom(unsigned short com)
{
mutex.lock();
if(!outPacketList.isEmpty())
{
//打印调试信息
DWHERE();
DPRINT("- - - > outPacketList.size():%d",outPacketList.size());
OutPacket * outPacketPtr = NULL;
QHashIterator<short, OutPacket *> iter(outPacketList);
while(iter.hasNext())
{
iter.next();
outPacketPtr = iter.value();
if(outPacketPtr->getCommand() == com)
{
outPacketList.remove(iter.key());
SAFE_DELETE(outPacketPtr);
//打印调试信息
DWHERE();
DPRINT("- - - > outPacketList.size():%d",outPacketList.size());
}
}
}
mutex.unlock();
}
void PacketProcesser::processReceiveIM(InPacket *inPacket)
{
if(inPacket->getBodyLen() > 15)
{
//发送收到应答信息，通知服务消息已收到，内容是收到的信息的前16字节
OutPacket *imReplyPacket = wingApp->packetBuilder->buildReceiveIMReplyPacket(inPacket);
wingApp->packetStorage->appendOutPacket(imReplyPacket);
}
else
{
SAFE_DELETE(inPacket);
return;
}
static short filter = 0; //用于过滤重复收到的包
short sequence = inPacket->getSequence();
if(filter == sequence)
{
SAFE_DELETE(inPacket);
return;
}
filter = sequence;
ReceiveIMPacket *receiveIMPacket = new ReceiveIMPacket();
receiveIMPacket->fromInPacket(inPacket);
switch(receiveIMPacket->imKind)
{
case ReceiveIMPacket::QQ_IM_FROM_USER:
wingApp->guiHandling->imFromUser(receiveIMPacket);
break;
case ReceiveIMPacket::QQ_IM_FROM_SYS:
wingApp->guiHandling->imFromSys(receiveIMPacket);
break;
case ReceiveIMPacket::QQ_IM_FROM_CLUSTER:
wingApp->guiHandling->imFromCluster(receiveIMPacket);
break;
case ReceiveIMPacket::QQ_IM_FROM_SMS:
wingApp->guiHandling->imFromSms(receiveIMPacket);
break;
case ReceiveIMPacket::CANNOT_PARSE:
{
SAFE_DELETE(receiveIMPacket);
//打印调试信息
DWHERE();
DPRINT("- - - > one im packet cannot be parsed!");
}
break;
default:
;
}
//打印调试信息
DWHERE();
DPRINT("- - - > receive ReceiveIMPacket!");
SAFE_DELETE(inPacket);
}
PacketStorage::~PacketStorage()
{
if(checker->isActive())
checker->stop();
SAFE_DELETE(checker);
if(keepAliveTimer->isActive())
keepAliveTimer->stop();
SAFE_DELETE(keepAliveTimer);
deleteAllPacket();
mutex.lock();
//设置结束线程标志
endThreadFlag = true;
packetListEmpty.wakeOne();
mutex.unlock();
//等待线程退出
wait();
//打印调试信息
DWHERE();
}
void PacketProcesser::processUnknownMsg(InPacket *inPacket)
{
//打印调试信息
DWHERE();
DPRINT("- - - > RECEIVE UNKNOWN InPacket! COMMAND:%#x", inPacket->getCommand());
SAFE_DELETE(inPacket);
}
void PacketProcesser::processOutPacketSlot(OutPacket *outPacket)
{
//打印调试信息
DWHERE();
DPRINT("- - - > new outpacket! command:%#x bodyLen:%d",outPacket->getCommand(), (int)outPacket->getBodyLen());
/*
#ifdef QT_DEBUG
uint8 *bodyPtr = outPacket->getBody();
int bodyLen = outPacket->getBodyLen();
for(int i=0; i<bodyLen; i++)
{
if(!(i%8))
fprintf(stderr, "\n%d: ", i);
fprintf(stderr, "%2x ", bodyPtr[i]);
}
fprintf(stderr, "\n");
fflush(stderr);
#endif
*/
uint8 *outStr = new uint8[QQ_PACKET_MAX_SIZE]; //65535
int len = 0;
outPacket->toByteArrary(outStr, &len);
wingApp->netManager->send(outStr, len);
//如果不是需要应答的包，删除
if(!outPacket->ifNeedAck())
SAFE_DELETE(outPacket);
}
void PacketProcesser::processGetOnlineFriendListReply(InPacket *inPacket)
{
static short filter = 0; //用于过滤重复收到的包
short sequence = inPacket->getSequence();
if(filter == sequence)
{
SAFE_DELETE(inPacket);
return;
}
filter = sequence;
//删除重发队列中的包
wingApp->packetStorage->removeNeedAckPacketBySeq(sequence);
uint8 *bodyPtr = inPacket->getBody();
int bodyLen = inPacket->getBodyLen();
uint8 *bodyCopy = new uint8[bodyLen];
memcpy(bodyCopy, bodyPtr, bodyLen);
uint8 endFlag;
endFlag = bodyPtr[0];
if(0xFF != endFlag)
{
OutPacket *getFriendList = wingApp->packetBuilder->buildFriendListRequestPacket(inPacket);
wingApp->packetStorage->appendOutPacket(getFriendList);
}
wingApp->buddyManager->putOnlineBuddyList(bodyCopy, bodyLen);
//打印调试信息
DWHERE();
DPRINT("- - - > receive GetOnlineFriendListReply!");
SAFE_DELETE(inPacket);
}
void PacketProcesser::processFriendChangeStatus(InPacket *inPacket)
{
static short filter = 0; //用于过滤重复收到的包
short sequence = inPacket->getSequence();
if(filter == sequence)
{
delete inPacket;
return;
}
filter = sequence;
uint32 pos = 0, sender;
uint8 sta;
uint8 *bodyPtr = inPacket->getBody();
ToolKit::readBufDW(bodyPtr, sender);
pos += 4;
pos += 8;
sta = bodyPtr[pos++];
wingApp->guiHandling->friendChangeStatus(sender, sta);
//打印调试信息
DWHERE();
DPRINT("- - - > receive FriendChangeStatus!");
SAFE_DELETE(inPacket);
}
void PacketProcesser::processNoAckPacketSlot(OutPacket *outPacket)
{
//取得接收包的命令字
short command = outPacket->getCommand();
switch(command)
{
case QQ_TOUCH_REQUEST:
case QQ_REQUEST_PRE_LOGIN_TOKEN:
case QQ_REQUEST_LOGIN_TOKEN:
case QQ_REQUEST_PRE_SESSION_KEY:
case QQ_REQUEST_SESSION_KEY:
{
WING_EVENT *loginFailed = new WING_EVENT(WING_EVENT::loginFailed,"PacketProcesser","login failed!",0);
wingApp->eventProcesser->longEventHandling(loginFailed);
}
break;
case QQ_KEEP_ALIVE:
{
WING_EVENT *fallLine = new WING_EVENT(WING_EVENT::fallLine,"PacketProcesser","wing has fall line !",0);
wingApp->eventProcesser->longEventHandling(fallLine);
}
break;
}
//打印调试信息
DWHERE();
DPRINT("- - - > failed to send msg!");
SAFE_DELETE(outPacket);
}
WingDialogWindow::~WingDialogWindow()
{
SAFE_DELETE(sysMsgBrowser);
//打印调试信息
DWHERE();
}
void PacketProcesser::processSendIMReply(InPacket *inPacket)
{
//删除重发队列中的包
wingApp->packetStorage->removeNeedAckPacketBySeq(inPacket->getSequence());
//打印调试信息
DWHERE();
DPRINT("- - - > receive SendIMReply!");
SAFE_DELETE(inPacket);
}
void PacketProcesser::processKeepAliveReply(InPacket *inPacket)
{
static short filter = 0; //用于过滤重复收到的包
short sequence = inPacket->getSequence();
if(filter == sequence)
{
SAFE_DELETE(inPacket);
return;
}
filter = sequence;
//删除重发队列中的包
wingApp->packetStorage->removeNeedAckPacketBySeq(sequence);
//打印调试信息
DWHERE();
DPRINT("- - - > receive keepAliveReplyPacket!");
SAFE_DELETE(inPacket);
}
void WingDialogWindow::onTreeItemDoubleClicked(WingTreeWidgetItem *item)
{
//打印调试信息
DWHERE();
DPRINT("- - - > onItemDoubleClicked:%u",item->buddyQQNum);
if(item->msgBrowser)
{
if(tabWidget->indexOf(item->msgBrowser) == -1)
tabWidget->addTab(item->msgBrowser, item->icon(0), item->text(0));
}
else
{
item->msgBrowser = new WingTextBrowser();
item->msgBrowser->buddyQQNum = item->buddyQQNum;
tabWidget->addTab(item->msgBrowser, item->icon(0), item->text(0));
}
tabWidget->setCurrentWidget(item->msgBrowser);
if(this->isHidden())
this->show();
}
void SerialThread_Write::run()
{
DWHERE();
while(!stopped)
{
msleep(100);
/*读取串口数据*/
if(port->isOpen())
{
// if (type)
// {
// QByteArray readByte;
// qint64 readNum = 0;
// while((readNum = port->bytesAvailable()) >= 1)
// {
// msleep(50);
// mutex.lock();
//// readByte = port->read(readNum);
// readByte = port->readAll();
// emit dataReceived(readByte);
// mutex.unlock();
// qDebug() << readByte;
// qDebug()<< "uft8_gbK :" << _From_UTF8_2_GBK(readByte);
// // foreach(char ch, readByte)
// // {
// // if((ch > 0)/* && (ch != 13) && (ch != 10) && (ch != 32)*/)
// // {
// // readStr.append(ch);
// // }
// // }
// // 读完数据后等待10 毫秒
// readNum = 0;
// readByte.clear();
// }
// }
// else //* ==我是读数据和写数据的分割线================================================*/
// {
while(isWrire)
{
if(!sendStr.isEmpty())
{
// int sendNum = writeStringToSerialPort(sendStr);
mutex.lock();
port->write(sendStr);
qint64 sendNum = sendStr.size();
qDebug() << "sendNum" << sendNum;
emit sig_sendNum(sendNum);
mutex.unlock();
}
if(continuesSend)
{
msleep(msc);
}
else
{
isWrire = false;
sendStr.clear();
msc = 0;
}
}
}
// }
}
}
void PacketStorage::run()
{
while(1)
{
mutex.lock();
//如果outPacketList和inPacketList同时为空且endThreadFlag为假时，则等待
while(outPacketList.isEmpty() && inPacketList.isEmpty() && !endThreadFlag)
packetListEmpty.wait(&mutex);
//如果释构标志被设置，则跳出循环，结束线程
if(endThreadFlag)
{
//打印调试信息
DWHERE();
break;
}
//发送包队列非空
if(!outPacketList.isEmpty())
{
//打印调试信息
DWHERE();
DPRINT("- - - > outPacketList.size():%d",outPacketList.size());
QHashIterator<short, OutPacket *> iter(outPacketList);
if(iter.hasNext())
{
iter.next();
OutPacket *outPacketPtr = iter.value();
//
wingApp->packetProcesser->processOutPacket(outPacketPtr);
if(outPacketPtr->ifNeedAck())
{
//如果需要应答，把它插入需应答队列
needAckPacketList.insert(iter.key(), iter.value());
//打印调试信息
DWHERE();
DPRINT("- - - > needAckPacketList.size():%d",needAckPacketList.size());
//包出队
outPacketList.remove(iter.key());
}
else
{
//包出队
outPacketList.remove(iter.key());
}
//打印调试信息
DWHERE();
DPRINT("- - - > outPacketList.size():%d",outPacketList.size());
}
}
//接收包队列非空
if(!inPacketList.isEmpty())
{
//打印调试信息
DWHERE();
DPRINT("- - - > inPacketList.size():%d",inPacketList.size());
QHashIterator<short, InPacket *> iter(inPacketList);
if(iter.hasNext())
{
iter.next();
InPacket *inPacketPtr = iter.value();
//送出一个接收包给WingController处理
wingApp->packetProcesser->processInPacket(inPacketPtr);
//打印调试信息
DWHERE();
DPRINT("- - - > longMainPtr->packetProcesser->processInPacket(inPacketPtr)");
//包出队
inPacketList.remove(iter.key());
}
//打印调试信息
DWHERE();
DPRINT("- - - > inPacketList.size():%d",inPacketList.size());
}
mutex.unlock();
}
}
WingUser::~WingUser()
{
//打印调试信息
DWHERE();
}
PacketProcesser::~PacketProcesser()
{
//打印调试信息
DWHERE();
}
WingTextBrowser::~WingTextBrowser()
{
//打印调试信息
DWHERE();
DPRINT("- - - > WingTextBrowser was destructed! qqNum:%u",buddyQQNum);
}
void PacketProcesser::processInPacketSlot(InPacket *inPacket)
{
//取得接收包的命令字
short command = inPacket->getCommand();
//打印调试信息
DWHERE();
DPRINT("- - - > new inpacket! command:%#x bodyLen:%d",command, inPacket->getBodyLen());
/*
#ifdef QT_DEBUG
uint8 *bodyPtr = inPacket->getBody();
int bodyLen = inPacket->getBodyLen();
for(int i=0; i<bodyLen; i++)
{
if(!(i%8))
fprintf(stderr, "\n%d: ", i);
fprintf(stderr, "%2x ", bodyPtr[i]);
}
fprintf(stderr, "\n");
fflush(stderr);
#endif
*/
switch(command)
{
//处理握手请求应答 0x0091
case QQ_TOUCH_REQUEST:
//处理预登陆令箭请求应答 0x0062
case QQ_REQUEST_PRE_LOGIN_TOKEN:
//处理登陆令箭请求应答 0x00ba
case QQ_REQUEST_LOGIN_TOKEN:
//处理预会话密钥应答 0X00DD
case QQ_REQUEST_PRE_SESSION_KEY:
//处理会话密钥应答 0x0022
case QQ_REQUEST_SESSION_KEY:
{
if(NULL != wingApp->loginModule)
wingApp->loginModule->processReply(inPacket);
else
processUnknownMsg(inPacket);
}
break;
//处理获取好友列表应答 0x0026
case QQ_GET_FRIEND_LIST:
processGetFriendListReply(inPacket);
break;
//处理获取在线好友应答 0x0027
case QQ_GET_FRIEND_ONLINE:
processGetOnlineFriendListReply(inPacket);
break;
//收到用户信息 0x0006
case QQ_GET_USER_INFO:
processGetUserInfoReply(inPacket);
break;
//保持在线（心跳信息）0x0002
case QQ_KEEP_ALIVE:
processKeepAliveReply(inPacket);
break;
//收到消息 0x0017
case QQ_RECV_IM:
processReceiveIM(inPacket);
break;
//收到发送消息的应答 0x0016
case QQ_SEND_IM:
processSendIMReply(inPacket);
break;
//收到好友状态改变信息 0x0081
case QQ_FRIEND_CHANGE_STATUS:
processFriendChangeStatus(inPacket);
break;
//收到用户状态改变应答信息 0x000D
case QQ_CHANGE_STATUS:
processUserChangeStatus(inPacket);
break;
//签名操作 0x0067
case QQ_SIGNATURE_OP:
processSignatureOpReply(inPacket);
break;
default:
processUnknownMsg(inPacket);
}
}
void ReceiveIMPacket::processUnknownIMPacket(InPacket *inPacket)
{
//打印调试信息
DWHERE();
DPRINT("- - - > there is one IMPacket not be processed!");
}
