wheeldetect/tpvs17/tpMain/lpRawTcp/lptkRawTcpServer.cpp

#include <QFile>
#include "lpRawTcpClientSession.h"
#include "lptkRawTcpServer.h"
#pragma execution_character_set("utf-8")
lptkRawTcpServer::lptkRawTcpServer(QObject *parent /*= NULL*/)
	: QTcpServer(parent)
{
	qRegisterMetaType<QSharedPointer<QByteArray>>();
	client_sessions_.clear();
}

lptkRawTcpServer::~lptkRawTcpServer()
{
	server_end();
}

bool lptkRawTcpServer::server_begin(const QString &strIP, quint16 nPort)
{
	QHostAddress listen_addr_ = QHostAddress::Any;
	QString ip_addr = strIP;
	quint16 listen_port_ = nPort;
	ip_addr.trimmed();
	_address = ip_addr;
	_port = nPort;
	if (ip_addr != "*")
	{
		listen_addr_.setAddress(ip_addr);
	}
	if (!this->listen(listen_addr_, nPort))
	{
		qWarning() << "Could not start server. Error: " << this->errorString()
			<< __FUNCTION__;

		return false;
	}
	else
	{
		qDebug() << "Server started. Listening to port " << nPort << __FUNCTION__;

		QVariantMap m_MapSock;
		m_MapSock.insert("type", QVariant("server"));
		m_MapSock.insert("server_address", strIP);
		m_MapSock.insert("server_port", nPort);
		//m_MapSock.insert("server_name", peerName);
		m_MapSock.insert("server_state", QVariant("is Open success "));
		emit(sgConnect(m_MapSock));
		return true;
	}
}

void lptkRawTcpServer::server_end()
{
	close();
	//close all connected session
	auto it = client_sessions_.begin();
	while (it != client_sessions_.end())
	{
		TP_RAW_CLIENT_SESS cli_sess = it.value();
		disconnect(cli_sess.pSess_);
		cli_sess.pSess_->force_close();
		
		cli_sess.pThrd_->quit();
		cli_sess.pThrd_->wait();
		if (cli_sess.pThrd_->isRunning()) {
			cli_sess.pThrd_->exit(0);
		}
		delete cli_sess.pThrd_;// ->deleteLater();
		delete cli_sess.pSess_;
		client_sessions_.erase(it++);
	}

	client_sessions_.clear();

	QVariantMap m_MapSock;
	m_MapSock.insert("type", QVariant("server"));
	m_MapSock.insert("server_address", _address);
	m_MapSock.insert("server_port", _port);
	m_MapSock.insert("server_state", QVariant("close listen "));
	emit(sgConnect(m_MapSock));
	//stop listening
	
}

void lptkRawTcpServer::incomingConnection(qintptr socketDescriptor)
{
	lpRawClientSession *pclientSess = nullptr;

	pclientSess = new lpRawClientSession(socketDescriptor);

	QThread *pThrd = new QThread();
	pclientSess->moveToThread(pThrd);

	TP_RAW_CLIENT_SESS cli_sess;
	cli_sess.pThrd_ = pThrd;
	cli_sess.pSess_ = pclientSess;
	if (_func)
	{
		pclientSess->setRecvCallBackFunc(_func);
	}
	
	//connect(pThrd, &QThread::finished, pclientSess, &QObject::deleteLater);
	connect(pclientSess, &lpRawClientSession::data_received, this, &lptkRawTcpServer::on_data_received);
	connect(pclientSess, &lpRawClientSession::sess_disconnected, this, &lptkRawTcpServer::on_sess_disconnected);

	connect(this, &lptkRawTcpServer::data_to_send, pclientSess, &lpRawClientSession::on_data_to_send);
	client_sessions_[socketDescriptor] = cli_sess;

	QString mAddress, mperrname;
	qint16 mport;
	QString strTgName = pclientSess->getInfo(mAddress, mport, mperrname);

	QVariantMap m_MapSock;
	m_MapSock.insert("type", QVariant("client"));
	m_MapSock.insert("client_address", mAddress);
	m_MapSock.insert("client_port", mport);
	m_MapSock.insert("client_name", mperrname);
	m_MapSock.insert("client_state", QVariant("connect"));

	pThrd->start();
	QString strIP = pclientSess->getClientIP();
	int n = strIP.lastIndexOf(":");
	strIP = strIP.mid(n).remove(":");
	int port = pclientSess->getClientPort();
	QString strID = QString("%1:%2").arg(strIP).arg(port);
	pclientSess->setClientID(strID);
	emit client_status_changed(socketDescriptor, TCPSERVER_ON_CLIENT_CONNECTED);
	emit client_connect_status(strID, TCPSERVER_ON_CLIENT_CONNECTED);
	emit sgConnect(m_MapSock);
}

void lptkRawTcpServer::on_data_received(int sess_id, QSharedPointer<QByteArray> data_ptr)
{
	auto it = client_sessions_.find(sess_id);
	if (it == client_sessions_.end())
	{
		qDebug() << "Invalid session ID : " << sess_id << __FUNCTION__;
		return;
	}

	emit data_received(sess_id, data_ptr);
}

void lptkRawTcpServer::on_sess_disconnected(int sess_id)
{
	auto it = client_sessions_.find(sess_id);
	if (it != client_sessions_.end())
	{
		TP_RAW_CLIENT_SESS cli_sess = it.value();
		cli_sess.pSess_->force_close();
		cli_sess.pThrd_->quit();
		cli_sess.pThrd_->wait();
		if (cli_sess.pThrd_->isRunning()) {
			cli_sess.pThrd_->exit(0);
		}

		QString strID = cli_sess.pSess_->getClientID();

		QString mAddress, mperrname;
		qint16 mport;
		QString strTgName = cli_sess.pSess_->getInfo(mAddress, mport, mperrname);

		QVariantMap m_MapSock;
		m_MapSock.insert("type", QVariant("client"));
		m_MapSock.insert("client_address", mAddress);
		m_MapSock.insert("client_port", mport);
		m_MapSock.insert("client_name", mperrname);
		m_MapSock.insert("client_state", QVariant("Disconnect"));

		emit sgConnect(m_MapSock);
		emit client_connect_status(strID, TCPSERVER_ON_CLIENT_DISCONNECTED);

		delete cli_sess.pThrd_;
		delete cli_sess.pSess_;
		client_sessions_.erase(it);
	}

	emit client_status_changed(sess_id, TCPSERVER_ON_CLIENT_DISCONNECTED);
}

void lptkRawTcpServer::send_data(int sess_id, QSharedPointer<QByteArray> data_ptr)
{
	auto it = client_sessions_.find(sess_id);
	if (it != client_sessions_.end())
	{
		TP_RAW_CLIENT_SESS cli_sess = it.value();
		emit data_to_send(it.key(), data_ptr);
	}
}

void lptkRawTcpServer::broadcast_send_data(QSharedPointer<QByteArray> data_ptr)
{
	auto it = client_sessions_.begin();
	while (it != client_sessions_.end())
	{
		TP_RAW_CLIENT_SESS cli_sess = it.value();
		emit data_to_send(it.key(), data_ptr);
		it++;
	}
}