C++ (Cpp) startInactivityDetection Examples

Example #1

File: channel.cpp Project: mzxdream/kbengine

//-------------------------------------------------------------------------------------
Channel::Channel(NetworkInterface & networkInterface,
		const EndPoint * endpoint, Traits traits, ProtocolType pt,
		PacketFilterPtr pFilter, ChannelID id):
	pNetworkInterface_(&networkInterface),
	traits_(traits),
	protocoltype_(pt),
	id_(id),
	inactivityTimerHandle_(),
	inactivityExceptionPeriod_(0),
	lastReceivedTime_(0),
	bundles_(),
	windowSize_(	(traits != INTERNAL)    ? EXTERNAL_CHANNEL_SIZE :
					(id == CHANNEL_ID_NULL) ? INTERNAL_CHANNEL_SIZE :
											  INDEXED_CHANNEL_SIZE),

	bufferedReceivesIdx_(0),
	pPacketReader_(0),
	isDestroyed_(false),
	// Stats
	numPacketsSent_(0),
	numPacketsReceived_(0),
	numBytesSent_(0),
	numBytesReceived_(0),
	lastTickBytesReceived_(0),
	pFilter_(pFilter),
	pEndPoint_(NULL),
	pPacketReceiver_(NULL),
	isCondemn_(false),
	proxyID_(0),
	strextra_(),
	channelType_(CHANNEL_NORMAL),
	componentID_(UNKNOWN_COMPONENT_TYPE),
	pMsgHandlers_(NULL)
{
	this->incRef();
	this->clearBundle();
	this->endpoint(endpoint);
	
	if(protocoltype_ == PROTOCOL_TCP)
	{
		pPacketReceiver_ = new TCPPacketReceiver(*pEndPoint_, networkInterface);
		// UDP不需要注册描述符
		pNetworkInterface_->dispatcher().registerFileDescriptor(*pEndPoint_, pPacketReceiver_);
	}
	else
		pPacketReceiver_ = new UDPPacketReceiver(*pEndPoint_, networkInterface);
	
	startInactivityDetection((traits == INTERNAL) ? g_channelInternalTimeout : g_channelExternalTimeout);
}

Example #2

File: Channel.cpp Project: yicaijun/snail

bool Channel::initialize(NetworkManager &networkMgr,
						 const EndPoint *pEndPoint, 
						 ETraits traits, 
						 ProtocolType protoType, 
						 PacketFilterPtr pFilter, 
						 ChannelID id)
{
	mID = id;
	mProtocolType = protoType;
	mTraits = traits;
	mpFilter = pFilter;
	mpNetworkManager = &networkMgr;
	this->pEndPoint(pEndPoint);

	Assert(mpNetworkManager != NULL);
	Assert(mpEndPoint != NULL);

	if(mProtocolType == Protocol_TCP)
	{
		if(mpPacketReceiver)
		{
			if(mpPacketReceiver->type() == PacketReceiver::ReceiverType_UDP)
			{
				SafeDelete(mpPacketReceiver);
				mpPacketReceiver = new TCPPacketReceiver(*mpEndPoint, *mpNetworkManager);
			}
		}
		else
		{
			mpPacketReceiver = new TCPPacketReceiver(*mpEndPoint, *mpNetworkManager);
		}

		mpNetworkManager->dispatcher().registerReadFileDescriptor(*mpEndPoint, mpPacketReceiver);

		// 需要发送数据时再注册
		// mpPacketSender = new TCPPacketSender(*pEndPoint_, *pNetworkInterface_);
		// mpNetworkManager->dispatcher().registerWriteFileDescriptor(*pEndPoint_, pPacketSender_);
	}
	else
	{
		if(mpPacketReceiver)
		{
			if(mpPacketReceiver->type() == PacketReceiver::ReceiverType_TCP)
			{
				SafeDelete(mpPacketReceiver);
				mpPacketReceiver = new UDPPacketReceiver(*mpEndPoint, *mpNetworkManager);
			}
		}
		else
		{
			mpPacketReceiver = new UDPPacketReceiver(*mpEndPoint, *mpNetworkManager);
		}
	}

	mpPacketReceiver->setEndPoint(mpEndPoint);
	if(mpPacketSender)
		mpPacketSender->setEndPoint(mpEndPoint);

	startInactivityDetection((mTraits == Internal) ? gChannelInternalTimeout : gChannelExternalTimeout,
							 (mTraits == Internal) ? gChannelInternalTimeout / 2.f : gChannelExternalTimeout / 2.f);

	return true;
}