C++ CChannel::RemoveStreamByLocalSid方法代码示例

void* CXEPxibb::OnPresenceJob(void* pvThis) throw()
{
	CXEPxibb* pXEPxibb = (CXEPxibb*) pvThis;
	CPresenceHandler* pPresenceHandler = &(pXEPxibb->PresenceHandler);
	CXMPPCore* pXMPPCore = pXEPxibb->pXMPPCore;

	CPresenceStanza PresenceStanza;

	while(pXMPPCore->Receive(pPresenceHandler, &PresenceStanza))
	{
		pXEPxibb->MutexOnChannelManager.Lock();
		
		try
		{
			CChannelManager* pChannelManager = pXEPxibb->GetChannelManager(PresenceStanza.GetFrom());

			if(pChannelManager != NULL)
			{
				for(u16 i = 0 ; i < pChannelManager->GetMaxChannel() ; i++)
				{
					CChannel* pChannel = pChannelManager->GetChannelByLocalCid(i);
					
					if(pChannel != NULL)
					{
						pXMPPCore->CommitHandler(pChannel->GetStreamOpenHandler());
						pXMPPCore->CommitHandler(pChannel->GetChannelDataHandler());
					
						for(u16 j = 0 ; j < pChannel->GetMaxStream() ; j++)
						{
							CStream* pStream = pChannel->GetStreamByLocalSid(j);
							
							if(pStream != NULL)
							{
								pXMPPCore->CommitHandler(pStream->GetStreamDataHandler());
								pChannel->RemoveStreamByLocalSid(j);
							}
						}
						
						pChannelManager->RemoveChannelByLocalCid(i);
					}
				}

				pXEPxibb->RemoveChannelManager(PresenceStanza.GetFrom());
			}
		}
		
		catch(exception& e)
		{
			#ifdef __DEBUG__
		cerr << e.what() << endl;
		#endif //__DEBUG__

		}
		
		pXEPxibb->MutexOnChannelManager.UnLock();
	}
	
	return NULL;
}

void CXEPxibb::CloseStream(const CJid& rJid, u16 localCid, u16 localSid)
{
	u16 remoteCid;
	u16 remoteSid;
	
	MutexOnChannelManager.Lock();

	try
	{
		// we are looking for the channelmanager associate to the Jid 		
		CChannelManager* pChannelManager = GetChannelManager(rJid);
				
		if(pChannelManager == NULL)
		throw CXEPxibbException(CXEPxibbException::XEPXEC_CLOSESTREAMERROR);
		
		// we are looking for the channel associate to the localCid
		CChannel* pChannel = pChannelManager->GetChannelByLocalCid(localCid);

		if(pChannel == NULL)
		throw CXEPxibbException(CXEPxibbException::XEPXEC_CLOSESTREAMERROR);

		remoteCid = pChannel->GetRemoteCid();

		// we are looking for the stream associate to the localSid
		CStream* pStream = pChannel->GetStreamByLocalSid(localSid);

		if(pStream == NULL)
		throw CXEPxibbException(CXEPxibbException::XEPXEC_CLOSESTREAMERROR);

		remoteSid = pStream->GetRemoteSid();

		pXMPPCore->CommitHandler(pStream->GetStreamDataHandler());
		pChannel->RemoveStreamByLocalSid(localSid);
	}
	
	catch(exception& e)
	{
		MutexOnChannelManager.UnLock();
		#ifdef __DEBUG__
		cerr << e.what() << endl;
		#endif //__DEBUG__

		throw CXEPxibbException(CXEPxibbException::XEPXEC_CLOSESTREAMERROR);
	}

	MutexOnChannelManager.UnLock();

	// we build the iq request
	string id;
	pXMPPCore->GenerateId(id);
	
	CStreamCloseStanza StreamCloseStanza(rJid, remoteCid, remoteSid, id);

	// we build the handler associate to the iq request
	CIQResultStanza IQResultStanza;
	CHandler IQResultHandler;

	CXMLFilter* pXMLFilter = new CXMLFilter("iq");
	pXMLFilter->SetAttribut("from", rJid.GetFull());
	pXMLFilter->SetAttribut("id", id);

	IQResultHandler.AddXMLFilter(pXMLFilter);
	
	pXMPPCore->RequestHandler(&IQResultHandler);

	// we send the iq request
	if(!pXMPPCore->Send(&StreamCloseStanza))
	throw CXEPxibbException(CXEPxibbException::XEPXEC_CLOSESTREAMERROR);

	// we receive the iq result
	if(!pXMPPCore->Receive(&IQResultHandler, &IQResultStanza))
	throw CXEPxibbException(CXEPxibbException::XEPXEC_CLOSESTREAMERROR);

	pXMPPCore->CommitHandler(&IQResultHandler);
	pXMPPCore->RemoveId(id);
}

void CXEPxibb::Detach()
{
	try
	{
		if(pXMPPCore == NULL)
		return;
	
		pXMPPCore->CommitHandler(&ChannelOpenHandler);
		pXMPPCore->CommitHandler(&ChannelCloseHandler);
		pXMPPCore->CommitHandler(&StreamCloseHandler);
		pXMPPCore->CommitHandler(&PresenceHandler);
	
		ThreadOnChannelCloseJob.Wait();
		ThreadOnStreamCloseJob.Wait();
		ThreadOnPresenceJob.Wait();
	
		for(u16 i = 0 ; i < ChannelManagerList.size() ; i++)
		{
			CChannelManager* pChannelManager = ChannelManagerList[i];
			
			if(pChannelManager != NULL)
			{
				for(u16 j = 0 ; j < pChannelManager->GetMaxChannel() ; j++)
				{
					CChannel* pChannel = pChannelManager->GetChannelByLocalCid(j);

					if(pChannel != NULL)
					{
						pXMPPCore->CommitHandler(pChannel->GetStreamOpenHandler());
						pXMPPCore->CommitHandler(pChannel->GetChannelDataHandler());
						
						for(u16 k = 0 ; k < pChannel->GetMaxStream() ; k++)
						{
							CStream* pStream = pChannel->GetStreamByLocalSid(k);
								
							if(pStream != NULL)
							{
								pXMPPCore->CommitHandler(pStream->GetStreamDataHandler());
								pChannel->RemoveStreamByLocalSid(k);
							}
						}

						pChannelManager->RemoveChannelByLocalCid(j);
					}	
				}
				
				delete pChannelManager;
				ChannelManagerList[i] = NULL;
			}
		}
	
		pXMPPCore = NULL;
	}
	
	catch(exception& e)
	{
		#ifdef __DEBUG__
		cerr << e.what() << endl;
		#endif //__DEBUG__

		throw CXEPxibbException(CXEPxibbException::XEPXEC_DETACHERROR);
	}
}

void* CXEPxibb::OnChannelCloseJob(void* pvThis) throw()
{
	CXEPxibb* pXEPxibb = (CXEPxibb*) pvThis;
	CChannelCloseHandler* pChannelCloseHandler = &(pXEPxibb->ChannelCloseHandler);
	CXMPPCore* pXMPPCore = pXEPxibb->pXMPPCore;

	CChannelCloseStanza ChannelCloseStanza;

	while(pXMPPCore->Receive(pChannelCloseHandler, &ChannelCloseStanza))
	{
		pXEPxibb->MutexOnChannelManager.Lock();
		
		try
		{
			CChannelManager* pChannelManager = pXEPxibb->GetChannelManager(ChannelCloseStanza.GetRemoteJid());

			if(pChannelManager != NULL)
			{
				CChannel* pChannel = pChannelManager->GetChannelByRemoteCid(ChannelCloseStanza.GetChannelId());

				if(pChannel != NULL)
				{
					pXMPPCore->CommitHandler(pChannel->GetStreamOpenHandler());
					pXMPPCore->CommitHandler(pChannel->GetChannelDataHandler());
				
					for(u16 i = 0 ; i < pChannel->GetMaxStream() ; i++)
					{
						CStream* pStream = pChannel->GetStreamByLocalSid(i);
						
						if(pStream != NULL)
						{
							pXMPPCore->CommitHandler(pStream->GetStreamDataHandler());
							pChannel->RemoveStreamByLocalSid(i);
						}
					}
				}
				
				pChannelManager->RemoveChannelByRemoteCid(ChannelCloseStanza.GetChannelId());
			}
		}
		
		catch(exception& e)
		{
			#ifdef __DEBUG__
		cerr << e.what() << endl;
		#endif //__DEBUG__

		}
		
		pXEPxibb->MutexOnChannelManager.UnLock();

		CIQResultStanza IQResultStanza;		
		IQResultStanza.SetTo(ChannelCloseStanza.GetRemoteJid());
		IQResultStanza.SetId(ChannelCloseStanza.GetId());
		 
		if(!pXMPPCore->Send(&IQResultStanza))
		return NULL;
	}
	
	return NULL;
}