Commit a0fbe9284b1538f9149b43581adcda3847f6f0a0

add client which can receive the server broadcast message, no handling yet though.


1	1	SET(
2	2	CLASSES
3	3	NetworkClient
	4	NetworkClient_ServerDiscoverer
4	5	)
5	6
6	7	SET(SOURCES)


1	1	#include "NetworkClient.h"
	2	#include "NetworkClient_ServerDiscoverer.h"
2	3
3	4	#include <QApplication>
4	5	#include <QDebug>
…	…
8	8	NetworkClient::NetworkClient()
9	9	: QObject(0)
10	10	{
	11	new ServerDiscoverer(this);
11	12	}
12	13
13	14	QString NetworkClient::pluginName() const


		1	#include "NetworkClient_ServerDiscoverer.h"
		2
		3	#include "../NetworkCommon/NetworkCommon.h"
		4
		5	#include <QUdpSocket>
		6
		7	NetworkClient::ServerDiscoverer::ServerDiscoverer(QObject* parent)
		8	: QObject(parent)
		9	, m_socket(new QUdpSocket(this))
		10	{
		11	m_socket->bind();
		12	connect(m_socket, SIGNAL(readyRead()), SLOT(handleResponses()));
		13	sendBroadcast();
		14	}
		15
		16	void NetworkClient::ServerDiscoverer::sendBroadcast()
		17	{
		18	m_socket->writeDatagram(NetworkCommon::discoveryMessage(), QHostAddress::Broadcast, NetworkCommon::portNumber());
		19	}
		20
		21	void NetworkClient::ServerDiscoverer::handleResponses()
		22	{
		23	while(m_socket->hasPendingDatagrams())
		24	{
		25	// don't worry about overflow, UDP packets have reasonable maximum size
		26	QByteArray payload;
		27	payload.resize(m_socket->pendingDatagramSize());
		28	QHostAddress source;
		29	quint16 sourcePort;
		30	m_socket->readDatagram(payload.data(), payload.size(), &source, &sourcePort);
		31	if(sourcePort != NetworkCommon::portNumber())
		32	{
		33	qDebug() << "Got a stray UDP packet from" << QString("%1:%2").arg(source.toString()).arg(sourcePort);
		34	continue;
		35	}
		36	else
		37	{
		38	qDebug() << "Got a response:" << payload;
		39	}
		40	}
		41	}


		1	#pragma once
		2
		3	#include "NetworkClient.h"
		4
		5	class QUdpSocket;
		6
		7	#include <QPair> // before QHostAddress for Qt 4.5
		8
		9	#include <QHostAddress>
		10
		11	class NetworkClient::ServerDiscoverer : public QObject
		12	{
		13	Q_OBJECT;
		14	public:
		15	ServerDiscoverer(QObject* parent);
		16	signals:
		17	void foundServer(const QString& name, const QByteArray& uuid, const QHostAddress& address, quint16 tcpPort);
		18	private slots:
		19	void sendBroadcast();
		20	void handleResponses();
		21	private:
		22	QUdpSocket* m_socket;
		23	};


		1	SET(
		2	CLASSES
		3	NetworkCommon
		4	)
		5
		6	SET(SOURCES)
		7	SET(HEADERS)
		8	FOREACH(class ${CLASSES})
		9	LIST(APPEND SOURCES ${class}.cpp)
		10	LIST(APPEND HEADERS ${class}.h)
		11	ENDFOREACH()
		12
		13	INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
		14	QT4_WRAP_CPP(MOC_SOURCES ${HEADERS})
		15	ADD_LIBRARY(
		16	NetworkCommon
		17	${SOURCES}
		18	${MOC_SOURCES}
		19	)


		1	#include "NetworkCommon.h"
		2
		3	#include <QDebug>
		4	#include <QtPlugin>
		5
		6	NetworkCommon::NetworkCommon()
		7	: QObject(0)
		8	{
		9	}
		10
		11	QString NetworkCommon::pluginName() const
		12	{
		13	return tr("Common Network Client/Server Plugin");
		14	}
		15
		16	QString NetworkCommon::pluginAuthor() const
		17	{
		18	return QString::fromLatin1("Fred Emmott");
		19	}
		20
		21	QString NetworkCommon::uniqueId() const
		22	{
		23	return "org.jerboaplayer.NetworkCommon";
		24	}
		25
		26	quint16 NetworkCommon::portNumber()
		27	{
		28	return 61719; // pseudo-random from private range
		29	}
		30
		31	QByteArray NetworkCommon::discoveryMessage()
		32	{
		33	return "Jerboa Network Discovery/1.0\n";
		34	}
		35
		36	Q_EXPORT_PLUGIN2(Jerboa_NetworkCommon, NetworkCommon);


		1	#pragma once
		2
		3	#include "Plugin.h"
		4
		5	#include <QObject>
		6
		7	class NetworkCommon: public QObject, public Jerboa::Plugin
		8	{
		9	Q_OBJECT;
		10	Q_INTERFACES(Jerboa::Plugin);
		11	public:
		12	NetworkCommon();
		13	QString pluginName() const;
		14	QString pluginAuthor() const;
		15	QString uniqueId() const;
		16
		17	static quint16 portNumber();
		18	static QByteArray discoveryMessage();
		19	};


1	1	#include "NetworkServer_Implementation.h"
2	2
	3	#include "../NetworkCommon/NetworkCommon.h"
	4
3	5	#include "Uuid.h"
4	6
5	7	#include <QDebug>
…	…
10	10	#include <QTcpServer>
11	11	#include <QUdpSocket>
12	12
13		const quint16 PORT_NUMBER = 61719; // pseudo-random from private range
14		const QByteArray DISCOVERY_MESSAGE = "Jerboa Network Discovery/1.0\n";
15
16	13	NetworkServer::Implementation::Implementation(Jerboa::CollectionInterface* collection, Jerboa::PlayerInterface* player, Jerboa::PlaylistInterface* playlist)
17	14	: QObject(0)
18	15	, m_collection(collection)
…	…
18	18	, m_discoverySocket(new QUdpSocket(this))
19	19	, m_server(new QTcpServer(this))
20	20	{
21		const bool startedDiscovery = m_discoverySocket->bind(QHostAddress::Any, PORT_NUMBER);
	21	const bool startedDiscovery = m_discoverySocket->bind(QHostAddress::Any, NetworkCommon::portNumber());
22	22	if(!startedDiscovery)
23	23	{
24	24	qDebug() << "Failed to start network discovery:" << m_discoverySocket->errorString();
…	…
108	108	QHostAddress source;
109	109	quint16 sourcePort;
110	110	m_discoverySocket->readDatagram(payload.data(), payload.size(), &source, &sourcePort);
111		if(payload == DISCOVERY_MESSAGE)
	111	if(payload == NetworkCommon::discoveryMessage())
112	112	{
113	113	qDebug() << "Received a discovery message from" << QString("%1:%2").arg(source.toString()).arg(sourcePort);
114	114	// send a response