void RobotCom::_float()
{
CMsg mOut;
mOut.WriteMessageType(CONTROL_MODE);
mOut.WriteInt(FLOAT);
sendMessage(mOut);
}
EXPORT_C gint32 CMsgIterator::Current(CDbEntity ** ppEntity)
{
guint32 mcId = 0;
if (ppEntity == NULL)
return ERROR(ESide_Client, EModule_Db, ECode_Invalid_Param);
*ppEntity = NULL;
if (m_dbQuery->eof())
return ERROR(ESide_Client, EModule_Db, ECode_Not_Exist);
/* fill msg table fields */
*ppEntity = new CMsg(m_pEntityDb);
if (NULL == *ppEntity)
{
return ERROR(ESide_Client, EModule_Db, ECode_No_Memory);
}
CMsg * pMsg = (CMsg*)(*ppEntity);
for (int i=0; i<MsgField_EndFlag; i++)
{
if (i == MsgField_ContentId)
mcId = atoi(m_dbQuery->fieldValue(i));
GString * fieldValue = g_string_new(m_dbQuery->fieldValue(i));
pMsg->SetFieldValue(i, fieldValue);
g_string_free(fieldValue, TRUE);
}
if (mcId != 0)
pMsg->GetMsgContent(mcId);
return 0;
}
DWORD CClientSock::SendFunc(LPVOID param)
{
CClientSock *pThis = (CClientSock*)param;
while (pThis->m_running)
{
CMsg tmp = pThis->m_sendList.PopMsg();
int len = send(pThis->m_sock,(char*)&tmp,tmp.GetMsgHead().len + sizeof(CMsgHead),0);
if (len < 0)
{
printf("remote server close sock\n");
pThis->Close();
break;
}
else if (len != tmp.GetMsgHead().len + sizeof(CMsgHead))
{
printf("send err\n");
//break;
}
else
{
printf("send ok\n");
}
continue;
}
return 0;
}
void CLogicThread::ThinkProc(CTaskDialog* Dialog,CMsg& Msg){
TASK_STATE State = Dialog->GetTaskState();
int64 EventID = Msg.GetEventID();
assert(EventID);
CLock lk(&m_Mutex);
ePipeline& Letter = m_TextMsgQueue[EventID];
assert(Letter.Size()==0);
Letter << Msg.GetLetter();
if (State == TASK_THINK)
{
return;
}
map<int64,ePipeline>::iterator it = m_TextMsgQueue.begin();
ePipeline& Letter1 = it->second;
EventID = it->first;
//下一个信息时间戳必须和上一个信息预先留下的一致
//例外是上一个信息留下的=0；
if (m_LastMsgTimeStamp !=0 && EventID != m_LastMsgTimeStamp )
{
return;
};
int64 Pos = Letter1.PopInt();
tstring text = Letter1.PopString();
EventID = Letter1.PopInt();
m_TextMsgQueue.erase(it);
ThinkProc(Dialog,Pos,text,true,EventID);
}
int CLoopFeederSink::ThreadMain(void)
{
while (SDL_SemWait(m_myMsgQueueSemaphore) == 0) {
CMsg* pMsg = m_myMsgQueue.get_message();
if (pMsg != NULL) {
switch (pMsg->get_value()) {
case MSG_NODE_STOP_THREAD:
DoStopSink();
delete pMsg;
return 0;
case MSG_NODE_START:
DoStartSink();
break;
case MSG_NODE_STOP:
DoStopSink();
break;
case MSG_SINK_FRAME:
uint32_t dontcare;
DoWriteFrame((CMediaFrame*)pMsg->get_message(dontcare));
break;
}
delete pMsg;
}
}
return -1;
}
INT4 COfGetConfigReplyHandler::handle(CSmartPtr<CMsgCommon> msg)
{
CMsg* ofmsg = (CMsg*)msg.getPtr();
LOG_DEBUG_FMT("%s[%p] handle new msg of path[%s] on sockfd[%d] ...",
toString(), this, ofmsg->getPath().c_str(), ofmsg->getSockfd());
INT4 sockfd = ofmsg->getSockfd();
CSmartPtr<CSwitch> sw = CControl::getInstance()->getSwitchMgr().getSwitch(sockfd);
if (sw.isNull())
{
LOG_WARN_FMT("CSwitch not created for sockfd[%d] !", sockfd);
COfConnectMgr::processSystemFailure(sockfd);
return BNC_ERR;
}
INT1* data = ofmsg->getData();
if (NULL == data)
{
LOG_WARN_FMT("%s[%p] received msg with no data from sockfd[%d] !",
toString(), this, sockfd);
return BNC_ERR;
}
LOG_DEBUG_FMT("send OFPT13_BARRIER_REQUEST to switch with sockfd[%d] ...", sockfd);
BOOL ret = COfMsgUtil::sendOfpMsg(sockfd, OFP13_VERSION, OFPT13_BARRIER_REQUEST);
if (!ret)
{
LOG_WARN_FMT("send OFPT13_BARRIER_REQUEST to switch with sockfd[%d] failed !", sockfd);
COfConnectMgr::processPeerEnterUnreach(sw);
return BNC_ERR;
}
return BNC_OK;
}
/*
* parse_decode_message - handle messages to the decode task
*/
void CPlayerMedia::parse_decode_message (int &thread_stop, int &decoding)
{
CMsg *newmsg;
if ((newmsg = m_decode_msg_queue.get_message()) != NULL) {
#ifdef DEBUG_DECODE_MSGS
media_message(LOG_DEBUG, "decode thread message %d",newmsg->get_value());
#endif
switch (newmsg->get_value()) {
case MSG_STOP_THREAD:
thread_stop = 1;
break;
case MSG_PAUSE_SESSION:
decoding = 0;
if (m_sync != NULL) {
m_sync->flush_decode_buffers();
}
break;
case MSG_START_DECODING:
if (m_sync != NULL) {
m_sync->flush_decode_buffers();
}
decoding = 1;
break;
}
delete newmsg;
}
}
// Audio encoding main process
int CAudioEncoder::ThreadMain(void)
{
CMsg* pMsg;
bool stop = false;
debug_message("audio encoder thread %s %s %s start", Profile()->GetName(),
Profile()->GetStringValue(CFG_AUDIO_ENCODER),
Profile()->GetStringValue(CFG_AUDIO_ENCODING));
while (stop == false && SDL_SemWait(m_myMsgQueueSemaphore) == 0) {
pMsg = m_myMsgQueue.get_message();
if (pMsg != NULL) {
switch (pMsg->get_value()) {
case MSG_NODE_STOP_THREAD:
DoStopAudio();
stop = true;
break;
case MSG_NODE_START:
// DoStartTransmit(); Anything ?
break;
case MSG_NODE_STOP:
DoStopAudio();
break;
case MSG_SINK_FRAME: {
uint32_t dontcare;
CMediaFrame *mf = (CMediaFrame*)pMsg->get_message(dontcare);
if (m_stop_thread == false)
ProcessAudioFrame(mf);
if (mf->RemoveReference()) {
delete mf;
}
break;
}
}
delete pMsg;
}
}
while ((pMsg = m_myMsgQueue.get_message()) != NULL) {
if (pMsg->get_value() == MSG_SINK_FRAME) {
uint32_t dontcare;
CMediaFrame *mf = (CMediaFrame*)pMsg->get_message(dontcare);
if (mf->RemoveReference()) {
delete mf;
}
}
delete pMsg;
}
if (m_audioResample != NULL) {
for (uint ix = 0; ix < m_audioDstChannels; ix++) {
st_resample_stop(m_audioResample[ix]);
m_audioResample[ix] = NULL;
}
free(m_audioResample);
}
CHECK_AND_FREE(m_audioPreEncodingBuffer);
debug_message("audio encoder thread %s exit", Profile()->GetName());
return 0;
}
INT4 COfRecvWorker::procRecvBuffer(INT4 sockfd, INT1* buffer, UINT4 len, CSmartPtr<CLoopBuffer>& recvBuffer)
{
struct ofp_header* header = NULL;
const UINT4 headerLen = sizeof(struct ofp_header);
UINT2 lenTotal = 0;
INT1* pdata = NULL, *pmsg = NULL;
CMsg* ofmsg = NULL;
CMsgTree& msgTree = CControl::getInstance()->getMsgTree();
while (len >= headerLen)
{
header = (struct ofp_header*)buffer;
lenTotal = ntohs(header->length);
if (lenTotal < headerLen)
{
LOG_WARN_FMT("%s drop packet when invalid ofp_header.length %u !!!", toString(), lenTotal);
return BNC_ERR;
}
if (len < lenTotal)
break;
procStats();
pdata = (INT1*)m_memPool.alloc(lenTotal);
if (NULL == pdata)
{
LOG_ERROR_FMT("alloc %u bytes failed!", lenTotal);
return BNC_ERR;
}
memcpy(pdata, buffer, lenTotal);
pmsg = (INT1*)m_memPool.alloc(sizeof(CMsg));
if (NULL == pmsg)
{
LOG_ERROR_FMT("alloc CMsg failed !");
m_memPool.release(pdata);
return BNC_ERR;
}
ofmsg = new(pmsg) CMsg(sockfd, header->version, header->type, pdata, lenTotal);
ofmsg->setPath();
ofmsg->setKey();
CSmartPtr<CMsgCommon> msg(ofmsg, deleteCmsg);
if (msgTree.pushMsg(msg) != BNC_OK)
{
LOG_INFO_FMT("push msg[%s]key[%s] from sockfd[%d] into tree failed",
ofmsg->getPath().c_str(), ofmsg->getKey().c_str(), sockfd);
}
buffer += lenTotal;
len -= lenTotal;
}
if (len > 0)
recvBuffer->write(buffer, len);
return BNC_OK;
}
int CALSAAudioSource::ThreadMain(void)
{
debug_message("alsa start");
while (true) {
int rc;
if (m_source) {
rc = SDL_SemTryWait(m_myMsgQueueSemaphore);
} else {
rc = SDL_SemWait(m_myMsgQueueSemaphore);
}
// semaphore error
if (rc == -1) {
break;
}
// message pending
if (rc == 0) {
CMsg* pMsg = m_myMsgQueue.get_message();
if (pMsg != NULL) {
switch (pMsg->get_value()) {
case MSG_NODE_STOP_THREAD:
DoStopCapture(); // ensure things get cleaned up
delete pMsg;
debug_message("alsa stop thread");
return 0;
case MSG_NODE_START:
DoStartCapture();
break;
case MSG_NODE_STOP:
DoStopCapture();
break;
}
delete pMsg;
}
}
if (m_source) {
try {
//debug_message("processaudio");
ProcessAudio();
}
catch (...) {
error_message("alsa stop capture");
DoStopCapture();
break;
}
}
}
debug_message("alsa thread exit");
return -1;
}
// get_type = GET_CURTIME (gv.curTime),
// GET_JPOS (gv.q), GET_JVEL (gv.dq), GET_TORQ (gv.tau),
// GET_IPOS (gv.x)
void RobotCom::getStatus( UiToServoMessageType get_type, float *arg )
{
if( get_type != GET_CURTIME && get_type != GET_JPOS
&& get_type != GET_JVEL && get_type != GET_TORQ
&& get_type != GET_IPOS )
return;
CMsg mOut;
mOut.Init();
mOut.WriteMessageType( get_type );
mOut.WriteInt( GUI );
sendMessage(mOut);
short expectedMesgType;
int numOfData;
switch( get_type )
{
case GET_CURTIME:
expectedMesgType = CURTIME_DATA;
numOfData = 1;
break;
case GET_JPOS:
expectedMesgType = JPOS_DATA;
numOfData = 6;
break;
case GET_JVEL:
expectedMesgType = JVEL_DATA;
numOfData = 6;
break;
case GET_TORQ:
expectedMesgType = TORQ_DATA;
numOfData = 6;
break;
case GET_IPOS:
expectedMesgType = IPOS_DATA;
numOfData = 7;
break;
}
for(;;)
{
if( IsDataAvailable() )
{
CMappedMsg mIn = GetMsg();
short mesgType = mIn.ReadMessageType();
//printf("Type = %d\n", mesgType );
if( mesgType == expectedMesgType )
{
mIn.ReadFloat( arg, numOfData );
return;
}
}
}
}
void RobotCom::control( ControlMode mode, float *arg, int numArgs )
{
CMsg mOut;
mOut.Init();
mOut.WriteMessageType(CONTROL_MODE);
mOut.WriteInt(mode);
if( numArgs > 0 )
mOut.WriteFloat( arg, numArgs );
sendMessage(mOut);
}
void RobotCom::controlGripper( float voltage )
{
if( voltage < -10.0 || 10.0 < voltage ) return;
CMsg mOut;
mOut.Init();
mOut.WriteMessageType(GRIPPER);
mOut.WriteInt( (int)(voltage * 4096.0 / 10.0) );
sendMessage(mOut);
}
void LoginConn::register_msgsvr()
{
IM::Register msgsvr;
msgsvr.set_port(g->get_listen_port());
CMsg packet;
packet.encode((int)M2L::REGISTER, msgsvr);
send(packet);
}
int main(int argc, char **argv)
{
int i = 3;
CQueue msgQue(5);
CMsg msgObj1(TRAFFIC, 20, "hello world!");
CMsg msgObj2(TRAFFIC, 30, "I will arrive at 3:00 AM");
CMsg msgObj3(TRAFFIC, 80, "Let's play football!");
CMsg msgObj4(TRAFFIC, 70, "did you recive my messages?");
CMsg msgObj5(TRAFFIC, 10, "Jolly, if you receive this message, pls call me. Ivan");
msgQue.InQueue(&msgObj1);
msgQue.InQueue(&msgObj2);
msgQue.InQueue(&msgObj3);
msgQue.InQueue(&msgObj4);
msgQue.InQueue(&msgObj5);
msgQue.travelQueue();
while( i > 0 )
{
if( msgQue.OutQueue() == true )
{
cout<<"OutQueue is ok!"<<endl;
}
else
{
return 0;
}
i--;
}
msgQue.travelQueue();
if ( msgQue.getCurrLength() != 0 )
{
const CMsg &retMsg = msgQue.getQueueMsg();
CMsg tmp_ptr = retMsg;
cout<<"outMsg->Type is : "<<tmp_ptr.getMsgType()<<endl;
cout<<"outMsg->Data is : "<<tmp_ptr.getMsgData()<<endl;
cout<<"outMsg->Info is : "<<tmp_ptr.getMsgInfo()<<endl;
}
else
cout<<"outQueue faile!"<<endl;
/* test operator+ */
CMsg msgObj6(TRAFFIC, 1000, "Man");
CMsg msgObj7(TRAFFIC, 1100, "and");
CMsg msgObj8(TRAFFIC, 1200, "women");
CMsg total;
total.operator+(msgObj6);
total.operator+(msgObj7);
total.operator+(msgObj8);
total.showCMsg();
//msgObj6 = msgObj6 + msgObj7 + msgObj8;
return 1;
}
void RouterConn::allocate_port()
{
// 向router注册,申请账号
IM::Allocate msg_port;
msg_port.set_port(9500);
CMsg packet;
packet.encode((int)M2R::ALLOCATE_PORT, msg_port);
send(packet);
}
int COSSAudioSource::ThreadMain(void)
{
while (true) {
int rc;
if (m_source) {
rc = SDL_SemTryWait(m_myMsgQueueSemaphore);
} else {
rc = SDL_SemWait(m_myMsgQueueSemaphore);
}
// semaphore error
if (rc == -1) {
break;
}
// message pending
if (rc == 0) {
CMsg* pMsg = m_myMsgQueue.get_message();
if (pMsg != NULL) {
switch (pMsg->get_value()) {
case MSG_NODE_STOP_THREAD:
DoStopCapture(); // ensure things get cleaned up
delete pMsg;
return 0;
case MSG_NODE_START:
case MSG_SOURCE_START_AUDIO:
DoStartCapture();
break;
case MSG_NODE_STOP:
DoStopCapture();
break;
}
delete pMsg;
}
}
if (m_source) {
try {
ProcessAudio();
}
catch (...) {
DoStopCapture();
break;
}
}
}
return -1;
}
void RouterConn::handle_channel_dispatch_chat(pb_message_ptr p_msg_)
{
TRY
auto descriptor = p_msg_->GetDescriptor();
const Reflection* rf = p_msg_->GetReflection();
const FieldDescriptor* f_send_id = descriptor->FindFieldByName("send_id");
const FieldDescriptor* f_recv_id = descriptor->FindFieldByName("recv_id");
const FieldDescriptor* f_content = descriptor->FindFieldByName("content");
const FieldDescriptor* f_send_tm = descriptor->FindFieldByName("send_time");
const FieldDescriptor* f_send_nm = descriptor->FindFieldByName("send_name");
const FieldDescriptor* f_channel_id = descriptor->FindFieldByName("channel_id");
assert(f_send_id && f_send_id->type()==FieldDescriptor::TYPE_INT64);
assert(f_recv_id && f_recv_id->type()==FieldDescriptor::TYPE_INT64);
assert(f_content && f_content->type()==FieldDescriptor::TYPE_BYTES);
assert(f_send_tm && f_send_tm->type()==FieldDescriptor::TYPE_STRING);
assert(f_send_nm && f_send_nm->type()==FieldDescriptor::TYPE_STRING);
assert(f_channel_id && f_channel_id->type()==FieldDescriptor::TYPE_INT32);
int64_t recv_id = rf->GetInt64(*p_msg_, f_recv_id);
// 玩家在这个服务器？
ImUser* pImUser = UserManager::get_instance()->get_user(recv_id);
if (pImUser != nullptr)
{
// 找到链接
connection_ptr conn = pImUser->get_conn();
if (conn != nullptr)
{
CMsg packet;
packet.encode((int)C2M::CHANNEL_CHAT, *p_msg_);
send(packet, conn->socket());
}
else
{
cout << "error: " << __FUNCTION__ << "Recv User(" << recv_id << ") conn isn't exists!" << endl;
}
}
else
{
cout << "error: " << __FUNCTION__ << " Recv User(" << recv_id << ") isn't exists!" << endl;
}
CATCH
}
// get_type = GET_CURTIME (gv.curTime),
// GET_JPOS (gv.q), GET_JVEL (gv.dq), GET_TORQ (gv.tau),
// GET_IPOS (gv.x)
void RobotCom::getStatus( UiToServoMessageType get_type, float *arg )
{
CMsg mOut;
mOut.Init();
mOut.WriteMessageType( get_type );
mOut.WriteInt( GUI );
sendMessage(mOut);
short expectedMesgType = NO_MSSG;
switch( get_type )
{
case GET_CURTIME:
expectedMesgType = CURTIME_DATA;
break;
case GET_JPOS:
expectedMesgType = JPOS_DATA;
break;
case GET_JVEL:
expectedMesgType = JVEL_DATA;
break;
case GET_TORQ:
expectedMesgType = TORQ_DATA;
break;
case GET_IPOS:
expectedMesgType = IPOS_DATA;
break;
default:
std::cout<<"Warning: RobotCom::getStatus: Unsupported messagetype provided!"<<std::endl;
return;
break;
}
for(;;)
{
if( IsDataAvailable() )
{
CMappedMsg mIn = GetMsg();
short mesgType = mIn.ReadMessageType();
int numData = mIn.ReadInt();
if( mesgType == expectedMesgType )
{
mIn.ReadFloat( arg, numData );
return;
}
}
}
}
void ggsstream::ProcessMessage() {
istringstream is(sMsg);
CMsg *pmsg;
pmsg=GetMsgType(is);
if (pmsg) {
pmsg->pgs=this;
pmsg->sRawText=sMsg;
pmsg->In(is);
Post(pmsg);
}
sMsg="";
}
void LoginConn::handle_UserValidate (pb_message_ptr p_msg_)
{
try
{
GOOGLE_PROTOBUF_VERIFY_VERSION;
using namespace google::protobuf;
auto descriptor = p_msg_->GetDescriptor();
const Reflection* rf = p_msg_->GetReflection();
const FieldDescriptor* f_req_id = descriptor->FindFieldByName("id");
const FieldDescriptor* f_passwd = descriptor->FindFieldByName("passwd");
assert(f_req_id && f_req_id->type()==FieldDescriptor::TYPE_INT64);
assert(f_passwd && f_passwd->type()==FieldDescriptor::TYPE_STRING);
int64_t id = rf->GetInt64(*p_msg_, f_req_id);
string passwd = rf->GetString(*p_msg_, f_passwd);
db_connect_ptr conn = ConnPool::get_instance()->get_free_conn();
bool result = m_sql_handler.validate(conn, id, passwd);
cout << "id: " << id << "validate result: " << result << endl;
IM::DBValidateResult db_result;
db_result.set_id(id);
db_result.set_result(result);
// release conn
ConnPool::get_instance()->release_conn(conn);
CMsg packet;
packet.encode((int)L2D::VALIDATE, db_result);
send(packet);
}
catch (exception& e)
{
cout << "# ERR: exception in " << __FILE__;
cout << "(" << __FUNCTION__ << ") on line " << __LINE__ << endl;
cout << "# ERR: " << e.what() << endl;
}
}
DWORD CClientSock::RecvFunc(LPVOID param)
{
CClientSock *pThis = (CClientSock*)param;
while (pThis->m_running)
{
CMsg tmp;
int len = recv(pThis->m_sock,(char*)&tmp,sizeof(CMsgHead),0);
if (len < 0)
{
printf("remote server drive to close sock\n");
break;
}
else if (len != sizeof(CMsgHead))
{
break;
}
int dstlen = tmp.GetMsgHead().len;
if (dstlen == 0)
{
pThis->m_recvList.PushMsg(tmp);
continue;
}
len = recv(pThis->m_sock,(char*)(&tmp+sizeof(CMsgHead)),dstlen,0);
if (len < 0)
{
printf("remote server drive to close sock\n");
break;
}
else if (len != dstlen)
{
printf("recv err\n");
continue;
//break;
}
pThis->m_recvList.PushMsg(tmp);
continue;
}
return 0;
}
static void deleteCmsg(CMsgCommon* msg)
{
if (NULL != msg)
{
CMsg* ofmsg = (CMsg*)msg;
INT4 sockfd = ofmsg->getSockfd();
ofmsg->~CMsg();
CSmartPtr<COfRecvWorker> worker = CServer::getInstance()->mapOfRecvWorker(sockfd);
if (worker.isNotNull())
worker->getMemPool().release(ofmsg);
else
LOG_WARN_FMT("memory[%p] not released for none COfRecvWorker by sockfd[%d] !", ofmsg, sockfd);
}
}
int CMsgQueue::send_message(CMsg *newmsg, SDL_sem *sem)
{
SDL_LockMutex(m_msg_queue_mutex);
if (m_msg_queue == NULL) {
m_msg_queue = newmsg;
} else {
CMsg *p = m_msg_queue;
while (p->get_next() != NULL) p = p->get_next();
p->set_next(newmsg);
}
SDL_UnlockMutex(m_msg_queue_mutex);
if (sem != NULL) {
SDL_SemPost(sem);
}
return (0);
}
DWORD CServerSock::SendFunc(LPVOID param)
{
//broadcast
CServerSock *pThis = (CServerSock*)param;
while (pThis->m_running)
{
CMsg tmp = pThis->m_sendList.PopMsg();
for (ClientSocketListIt iter = pThis->m_clientList.begin();iter!=pThis->m_clientList.end();++iter)
{
int len = send(*iter,(char*)&tmp,tmp.GetMsgHead().len + sizeof(CMsgHead),0);
if (len != tmp.GetMsgHead().len + sizeof(CMsgHead))
{
break;
}
}
}
return 0;
}
CMsg *CMsgQueue::get_message (void)
{
CMsg *ret;
if (m_msg_queue == NULL)
return(NULL);
SDL_LockMutex(m_msg_queue_mutex);
if (m_msg_queue == NULL)
ret = NULL;
else {
ret = m_msg_queue;
m_msg_queue = ret->get_next();
}
SDL_UnlockMutex(m_msg_queue_mutex);
if (ret) {
ret->set_next(NULL);
}
return (ret);
}
/*
* process_msg_queue - receive messages for the sync task. Most are
* state changes.
*/
int CPlayerSession::process_msg_queue (int state)
{
CMsg *newmsg;
while ((newmsg = m_sync_thread_msg_queue.get_message()) != NULL) {
#ifdef DEBUG_SYNC_MSGS
sync_message(LOG_DEBUG, "Sync thread msg %d", newmsg->get_value());
#endif
switch (newmsg->get_value()) {
case MSG_PAUSE_SESSION:
state = SYNC_STATE_PAUSED;
break;
case MSG_START_SESSION:
if (state != SYNC_STATE_INIT)
state = SYNC_STATE_WAIT_SYNC;
break;
case MSG_STOP_THREAD:
state = SYNC_STATE_EXIT;
break;
case MSG_SYNC_RESIZE_SCREEN: {
CVideoSync *vs = m_video_list;
while (vs != NULL) {
vs->set_screen_size(m_screen_scale);
if (m_video_count == 1) {
vs->set_fullscreen(m_fullscreen);
}
vs->do_video_resize(m_pixel_width, m_pixel_height,
m_max_width, m_max_height);
vs = vs->GetNextVideo();
}
}
break;
default:
sync_message(LOG_ERR, "Sync thread received message %d",
newmsg->get_value());
break;
}
delete newmsg;
newmsg = NULL;
}
return (state);
}
CMsg CMsgObjectInfo::Execute( CMsg &x_rMsg )
{
// Lock the handler list
CTlLocalLock ll( m_lockMsgHandlers );
if ( !ll.IsLocked() )
return CMsg();
// See if we have a destination for this address
CMsgTarget mt = m_lstMsgHandlers[ x_rMsg.Mi().Dst()->GetId() ];
if ( !mt.IsValid() )
return CMsg();
return mt( x_rMsg );
}
void LoginConn::handle_lookup(pb_message_ptr p_msg_)
{
TRY
auto descriptor = p_msg_->GetDescriptor();
const Reflection* rf = p_msg_->GetReflection();
const FieldDescriptor* f_req_id = descriptor->FindFieldByName("id");
assert(f_req_id && f_req_id->type()==FieldDescriptor::TYPE_INT64);
int id = rf->GetInt64(*p_msg_, f_req_id);
ImUser* pUser = UserManager::get_instance()->get_user(id);
IM::LookUpRes res;
res.set_id(id);
if(pUser != nullptr)
{
res.set_is_logined(1);
}
else
{
res.set_is_logined(0);
}
CMsg packet;
packet.encode((int)M2L::LOOKUP, res);
send_to_login(packet);
CATCH
}
int64 CLinkerPipe::PushMsgToSend(CMsg& Msg,bool bUrgence){
assert(Msg.IsValid());
CLock lk(m_Mutex,this);
ePipeline& Sender = Msg.GetSender();
ePipeline& Receiver = Msg.GetReceiver();
ePipeline& Letter = Msg.GetLetter();
int64 MsgID = Letter.GetID();
assert(MsgID != 0);
if (MsgID==0)
{
return 0;
}
int64 EventID = Msg.GetEventID();
//把本地发送者地址用一个INT64代替
int64 SenderID = LocalAddress2SenderID(Sender);
Sender.Clear();
Sender.PushInt(SenderID);
//用时间戳代替源ID，对方返回此时间戳表示正常接受
int64 TimeStamp = CreateTimeStamp();
Msg.SetSourceID(TimeStamp);
ePipeline* MsgPtr = (ePipeline*)Msg.Release();
Encrypt(MsgPtr);
ePipeline Info;
Info.PushInt(MsgID);
Info.PushInt(EventID);
Info.PushInt(TimeStamp);
Info.PushInt(m_PendingMsgID);
Info.PushInt(Size());
Info.PushInt(m_UrgenceMsg.Size());
m_Parent->NotifyLinkerState(this,LINKER_PUSH_MSG,Info);
if (bUrgence)
{
m_UrgenceMsg.Push_Directly(MsgPtr);
}else{
Push_Directly(MsgPtr);
}
return MsgID;
};
