Initial commit

1 files changed, 582 insertions, 0 deletions

diff --git a/Minecraft.Client/Durango/Network/DQRNetworkManager.h b/Minecraft.Client/Durango/Network/DQRNetworkManager.h
new file mode 100644
index 00000000..5f7b8d90
--- /dev/null
+++ b/Minecraft.Client/Durango/Network/DQRNetworkManager.h
@@ -0,0 +1,582 @@
+#pragma once
+
+#include "DQRNetworkPlayer.h"
+#include "..\Minecraft.World\C4JThread.h"
+#include <collection.h>
+
+class IDQRNetworkManagerListener;
+class PartyController;
+
+class DQRNetworkManager;
+class ChatIntegrationLayer;
+
+namespace MXS = Microsoft::Xbox::Services;
+namespace MXSM = Microsoft::Xbox::Services::Multiplayer;
+namespace MXSS = Microsoft::Xbox::Services::Social;
+namespace WXM = Windows::Xbox::Multiplayer;
+namespace WXN = Windows::Xbox::Networking;
+namespace WXNRs = Windows::Xbox::Networking::RealtimeSession;
+namespace WFC = Windows::Foundation::Collections;
+
+#define MATCH_SESSION_TEMPLATE_NAME    L"PeerToHostTemplate"
+#define MAX_PLAYERS_IN_TEMPLATE		   8
+
+using namespace std;
+
+ref class DQRNetworkManagerEventHandlers sealed
+{
+internal:
+	DQRNetworkManagerEventHandlers(DQRNetworkManager *pDQRNet);
+public:
+	void Setup(WXNRs::Session^ session);
+	void Pulldown(WXNRs::Session^ session);
+
+    void DataReceivedHandler(Platform::Object^ session, WXNRs::DataReceivedEventArgs^ args);
+    void SessionAddressDataChangedHandler(Platform::Object^ session, WXNRs::SessionAddressDataChangedEventArgs^ args);
+    void SessionStatusUpdateHandler(Platform::Object^ session, WXNRs::SessionStatusUpdateEventArgs^ args);
+    void AddedSessionAddressHandler(Platform::Object^ session, WXNRs::AddedSessionAddressEventArgs^ args);
+    void RemovedSessionAddressHandler(Platform::Object^ session, WXNRs::RemovedSessionAddressEventArgs^ args);
+    void GlobalSessionDataChangedHandler(Platform::Object^ session, WXNRs::GlobalSessionDataChangedEventArgs^ args);
+
+private:
+    Windows::Foundation::EventRegistrationToken	m_dataReceivedToken;
+    Windows::Foundation::EventRegistrationToken	m_sessionStatusToken;
+    Windows::Foundation::EventRegistrationToken	m_sessionAddressToken;
+    Windows::Foundation::EventRegistrationToken	m_addedSessionToken;
+    Windows::Foundation::EventRegistrationToken	m_removedSessionToken;
+    Windows::Foundation::EventRegistrationToken	m_globalDataToken;
+
+	DQRNetworkManager *m_pDQRNet;
+};
+
+typedef enum
+{
+	DQR_INTERNAL_ASSIGN_SMALL_IDS,
+	DQR_INTERNAL_UNASSIGN_SMALL_ID,
+	DQR_INTERNAL_PLAYER_TABLE,
+	DQR_INTERNAL_ADD_PLAYER_FAILED,
+};
+
+class DQRConnectionInfo
+{
+public:
+	typedef enum
+	{
+		ConnectionState_HeaderByte0,
+		ConnectionState_HeaderByte1,
+		ConnectionState_ReadBytes
+	} eDQRConnectionState;
+
+	typedef enum
+	{
+		ConnectionState_InternalHeaderByte,
+		ConnectionState_InternalAssignSmallIdMask,
+		ConnectionState_InternalAssignSmallId0,
+		ConnectionState_InternalAssignSmallId1,
+		ConnectionState_InternalAssignSmallId2,
+		ConnectionState_InternalAssignSmallId3,
+		ConnectionState_InternalRoomSyncData,
+		ConnectionState_InternalAddPlayerFailedData,
+	} eDQRInternalDataState;
+
+	DQRConnectionInfo();
+	void		  Reset();
+
+	eDQRConnectionState		m_state;
+	eDQRInternalDataState	m_internalDataState;
+
+	int						m_currentChannel;
+	bool					m_internalFlag;
+	int						m_bytesRemaining;
+	int						m_roomSyncDataBytesRead;
+	int						m_roomSyncDataBytesToRead;
+	unsigned char *			m_pucRoomSyncData;
+	int						m_addFailedPlayerDataBytesRead;
+	int						m_addFailedPlayerDataBytesToRead;
+	unsigned char *			m_pucAddFailedPlayerData;
+	unsigned char			m_smallId[4];
+	bool					m_channelActive[4];
+	unsigned char			m_smallIdReadMask;
+	unsigned char			*m_pucsmallIdReadMaskResolved;
+	bool					m_initialPacketReceived;
+};
+
+
+class DQRNetworkManager
+{
+	friend class PartyController;
+	friend ref class DQRNetworkManagerEventHandlers;
+	friend class DQRNetworkPlayer;
+	friend class ChatIntegrationLayer;
+public:
+	static const int JOIN_PACKET_RESEND_DELAY_MS = 200;
+	static const int JOIN_PACKET_RESEND_TIMEOUT_MS = 20000;
+	static const int JOIN_RESERVATION_WAIT_TIME = 30000;
+	static const int JOIN_CREATE_SESSION_MAX_ATTEMPTS = 5;
+
+	static const int PRIMARY_PLAYER_LEAVING_PARTY_WAIT_MS = 20000;		// Time between primary player leaving and when we should respond to it, to allow time for us to receive a new party for them to be going to if they are just changing party rather than leaving altogether
+
+	class SessionInfo
+	{
+	public:
+		SessionInfo(wstring& sessionName, wstring& serviceConfig, wstring& sessionTemplate);
+		SessionInfo();
+		bool m_detailsValid;
+		wstring m_sessionName;
+		wstring m_serviceConfig;
+		wstring m_sessionTemplate;
+	};
+
+	static const int MAX_LOCAL_PLAYER_COUNT = 4;
+	static const int MAX_ONLINE_PLAYER_COUNT = 8;
+	static const int MAX_ONLINE_PLAYER_NAME_LENGTH = 21;
+
+	// This class stores everything about a player that must be synchronised between machines. 
+	class PlayerSyncData
+	{
+	public:
+		wchar_t						*m_XUID;								// XUID / XboxUserIds are passed round as decimal strings on Xbox 1
+		uint32_t					m_sessionAddress;						// XRNS session address for this player, ie can identify which machine this player is on
+		uint8_t						m_smallId;								// Assigned by DQRNetworkManager, to attach a permanent id to this player (until we have to wrap round), to match a similar concept in qnet
+		uint8_t						m_channel;								// Local index / communication channel within session address, of player on this machine
+		wchar_t						m_name[MAX_ONLINE_PLAYER_NAME_LENGTH];
+	};
+
+	class RoomSyncData
+	{
+	public:
+		int				playerCount;
+		PlayerSyncData	players[MAX_ONLINE_PLAYER_COUNT];
+	};
+
+	class HostGamertagResolveDetails
+	{
+	public:;
+		DQRNetworkPlayer*	m_pPlayer;
+		wstring				m_name;
+		unsigned int		m_sessionAddress;
+		int					m_channel;
+		bool				m_sync;
+	};
+
+	DQRNetworkManager(IDQRNetworkManagerListener *listener);
+	void Initialise();
+	void EnableDebugXBLContext(MXS::XboxLiveContext^ XBLContext);
+
+	void CreateAndJoinSession(int userMask, unsigned char *customSessionData, unsigned int customSessionDataSize, bool offline);
+	void JoinSession(int playerMask);
+	void JoinSessionFromInviteInfo(int playerMask);
+	bool AddUsersToSession(int playerMask, MXSM::MultiplayerSessionReference^ sessionRef );
+	void UpdateCustomSessionData();
+
+	bool AddLocalPlayerByUserIndex(int userIndex);
+	bool RemoveLocalPlayerByUserIndex(int userIndex);
+
+	bool IsHost();
+	bool IsInSession();
+
+	// Player retrieval
+	int					GetPlayerCount();
+	int					GetOnlinePlayerCount();
+	DQRNetworkPlayer	*GetPlayerByIndex(int idx);
+	DQRNetworkPlayer	*GetPlayerBySmallId(int idx);
+	DQRNetworkPlayer	*GetPlayerByXuid(PlayerUID xuid);
+	wstring				GetDisplayNameByGamertag(wstring gamertag);
+	DQRNetworkPlayer	*GetLocalPlayerByUserIndex(int idx);
+	DQRNetworkPlayer	*GetHostPlayer();
+	int					GetSessionIndex(DQRNetworkPlayer *player);
+	void				Tick();
+	void				Tick_XRNS();
+	void				Tick_VoiceChat();
+	void				Tick_Party();
+	void				Tick_CustomSessionData();
+	void				Tick_AddAndRemoveLocalPlayers();
+	void				Tick_ResolveGamertags();
+	void				Tick_PartyProcess();
+	void				Tick_StateMachine();
+	void				Tick_CheckInviteParty();
+
+	bool				ShouldMessageForFullSession();
+	void				FlagInvitedToFullSession();
+	void				UnflagInvitedToFullSession();
+	// Externally exposed state. All internal states are mapped to one of these broader states.
+	typedef enum
+	{
+		DNM_STATE_INITIALISING,
+		DNM_STATE_INITIALISE_FAILED,
+		DNM_STATE_IDLE,
+
+		DNM_STATE_HOSTING,
+		DNM_STATE_JOINING,
+
+		DNM_STATE_STARTING,
+		DNM_STATE_PLAYING,		
+
+		DNM_STATE_LEAVING,
+		DNM_STATE_ENDING,
+	} eDQRNetworkManagerState;
+
+	eDQRNetworkManagerState												GetState();
+
+	class SessionSearchResult
+	{
+	public:
+		SessionSearchResult() { m_extData = NULL; }
+		~SessionSearchResult() { free(m_extData); }
+		wstring			m_partyId;
+		wstring			m_sessionName;
+
+		// These names/xuids reflect the server controlled list of who is actually in the game
+		wstring			m_playerNames[MAX_ONLINE_PLAYER_COUNT];
+		PlayerUID		m_playerXuids[MAX_ONLINE_PLAYER_COUNT];
+		int				m_playerCount;
+
+		// This count & set of xuids reflects the session document list of who is in the game
+		wstring			m_sessionXuids[MAX_ONLINE_PLAYER_COUNT];
+		int				m_usedSlotCount;
+
+		void			*m_extData;
+	};
+
+protected:
+	// NOTE: If anything changes in here, then the mapping from internal -> external state needs to be updated (m_INTtoEXTStateMappings, defined in the cpp file)
+	typedef enum
+	{
+		DNM_INT_STATE_INITIALISING,
+		DNM_INT_STATE_INITIALISE_FAILED,
+		DNM_INT_STATE_IDLE,
+		DNM_INT_STATE_HOSTING,
+		DNM_INT_STATE_HOSTING_WAITING_TO_PLAY,
+		DNM_INT_STATE_HOSTING_FAILED,
+		DNM_INT_STATE_JOINING,
+		DNM_INT_STATE_JOINING_WAITING_FOR_RESERVATIONS,
+		DNM_INT_STATE_JOINING_GET_SDA,
+		DNM_INT_STATE_JOINING_WAITING_FOR_SDA,
+		DNM_INT_STATE_JOINING_CREATE_SESSION,
+		DNM_INT_STATE_JOINING_WAITING_FOR_ACTIVE_SESSION,
+		DNM_INT_STATE_JOINING_SENDING_UNRELIABLE,
+		DNM_INT_STATE_JOINING_FAILED_TIDY_UP,
+		DNM_INT_STATE_JOINING_FAILED,
+		DNM_INT_STATE_STARTING,
+		DNM_INT_STATE_PLAYING,
+		DNM_INT_STATE_LEAVING,
+		DNM_INT_STATE_LEAVING_FAILED,
+		DNM_INT_STATE_ENDING,
+		DNM_INT_STATE_COUNT
+	} eDQRNetworkManagerInternalState;
+
+	typedef enum
+	{
+		DNM_ADD_PLAYER_STATE_IDLE,
+		DNM_ADD_PLAYER_STATE_PROCESSING,
+		DNM_ADD_PLAYER_STATE_COMPLETE_SUCCESS,
+		DNM_ADD_PLAYER_STATE_COMPLETE_FAIL,
+		DNM_ADD_PLAYER_STATE_COMPLETE_FAIL_FULL,
+	} eDQRAddLocalPlayerState;
+
+	typedef enum
+	{
+		DNM_REMOVE_PLAYER_STATE_IDLE,
+		DNM_REMOVE_PLAYER_STATE_PROCESSING,
+		DNM_REMOVE_PLAYER_STATE_COMPLETE_SUCCESS,
+		DNM_REMOVE_PLAYER_STATE_COMPLETE_FAIL,
+	} eDQRRemoveLocalPlayerState;
+
+	class StateChangeInfo
+	{
+	public:
+		eDQRNetworkManagerState m_oldState;
+		eDQRNetworkManagerState m_newState;
+		StateChangeInfo(eDQRNetworkManagerState oldState, eDQRNetworkManagerState newState) : m_oldState(oldState), m_newState(newState) {}
+	};
+
+	typedef enum
+	{
+		// Incoming messages
+		RTS_MESSAGE_DATA_RECEIVED,
+		RTS_MESSAGE_DATA_RECEIVED_CHAT,
+		RTS_MESSAGE_ADDED_SESSION_ADDRESS,
+		RTS_MESSAGE_REMOVED_SESSION_ADDRESS,
+		RTS_MESSAGE_STATUS_ACTIVE,
+		RTS_MESSAGE_STATUS_TERMINATED,
+
+		// Outgoing messages
+		RTS_MESSAGE_START_CLIENT,
+		RTS_MESSAGE_START_HOST,
+		RTS_MESSAGE_TERMINATE,
+		RTS_MESSAGE_SEND_DATA,
+	} eRTSMessageType;
+
+	typedef enum
+	{
+		RTS_MESSAGE_FLAG_BROADCAST_MODE = 1,
+		RTS_MESSAGE_FLAG_RELIABLE = 2,
+		RTS_MESSAGE_FLAG_SEQUENTIAL = 4,
+		RTS_MESSAGE_FLAG_COALESCE = 8,
+		RTS_MESSAGE_FLAG_GAME_CHANNEL = 16,
+	} eRTSFlags;
+
+	class RTS_Message
+	{
+	public:
+		eRTSMessageType m_eType;
+		unsigned int	m_sessionAddress;
+		unsigned char	*m_pucData;
+		unsigned int	m_dataSize;
+		unsigned int	m_flags;
+	};
+
+	std::queue<StateChangeInfo>											m_stateChangeQueue;
+	CRITICAL_SECTION													m_csStateChangeQueue;
+	CRITICAL_SECTION													m_csSendBytes;
+	CRITICAL_SECTION													m_csPartyViewVector;
+	std::queue<RTS_Message>												m_RTSMessageQueueIncoming;
+	CRITICAL_SECTION													m_csRTSMessageQueueIncoming;
+	std::queue<RTS_Message>												m_RTSMessageQueueOutgoing;
+	CRITICAL_SECTION													m_csRTSMessageQueueOutgoing;
+private:
+	void																SetState(DQRNetworkManager::eDQRNetworkManagerInternalState state);
+	static const eDQRNetworkManagerState								m_INTtoEXTStateMappings[DNM_INT_STATE_COUNT];
+	eDQRNetworkManagerInternalState										m_state;
+	eDQRNetworkManagerState												m_stateExternal;
+	__int64																m_lastUnreliableSendTime;
+	__int64																m_firstUnreliableSendTime;
+	__int64																m_startedWaitingForReservationsTime;
+	unsigned char														*m_customSessionData;
+	unsigned int														m_customSessionDataSize;
+	int																	m_customDataDirtyUpdateTicks;
+	std::shared_ptr<ChatIntegrationLayer>								m_chat;
+
+	eDQRAddLocalPlayerState												m_addLocalPlayerState;
+	DQRNetworkPlayer													*m_addLocalPlayerSuccessPlayer;
+	int																	m_addLocalPlayerSuccessIndex;
+	int																	m_addLocalPlayerFailedIndex;
+
+	eDQRRemoveLocalPlayerState											m_removeLocalPlayerState;
+	int																	m_removeLocalPlayerIndex;
+
+	Windows::Xbox::System::User^										m_primaryUser;
+	MXS::XboxLiveContext^												m_primaryUserXboxLiveContext;
+	WXN::SecureDeviceAssociationTemplate^								m_associationTemplate;
+
+	CRITICAL_SECTION													m_csRoomSyncData;
+	RoomSyncData														m_roomSyncData;
+	DQRNetworkPlayer													*m_players[MAX_ONLINE_PLAYER_COUNT];	
+
+	IDQRNetworkManagerListener											*m_listener;
+	PartyController														*m_partyController;
+	DQRNetworkManagerEventHandlers^										m_eventHandlers;
+	WXNRs::Session^														m_XRNS_Session;
+	unsigned int														m_XRNS_LocalAddress;
+	unsigned int														m_XRNS_OldestAddress;
+	MXSM::MultiplayerSession^											m_multiplayerSession;
+	WXN::SecureDeviceAssociation^										m_sda;
+	Platform::String^													m_secureDeviceAddressBase64;
+	unsigned char														m_currentSmallId;
+	unsigned char														m_hostSmallId;
+	bool																m_isHosting;
+	bool																m_isInSession;
+	bool																m_isOfflineGame;
+public:
+	int																	m_currentUserMask;
+private:
+	int																	m_joinSessionUserMask;
+	Platform::Array<Platform::String^>^									m_joinSessionXUIDs;
+	int																	m_joinSmallIdMask;
+
+	Platform::Array<BYTE>^												m_remoteSocketAddress;
+	Platform::Array<BYTE>^												m_localSocketAddress;
+	int																	m_joinCreateSessionAttempts;
+
+	C4JThread															*m_CreateSessionThread;
+	C4JThread															*m_LeaveRoomThread;		
+	C4JThread															*m_TidyUpJoinThread;
+	C4JThread															*m_UpdateCustomSessionDataThread;
+	C4JThread															*m_RTS_DoWorkThread;
+	C4JThread															*m_CheckPartyInviteThread;
+
+	bool																m_notifyForFullParty;
+
+	unordered_map<unsigned int,DQRConnectionInfo *>						m_sessionAddressToConnectionInfoMapHost;	// For host - there may be more than one remote session attached to this listening session
+	unsigned int														m_sessionAddressFromSmallId[256];			// For host - for mapping back from small Id, to session address
+	unsigned char														m_channelFromSmallId[256];					// For host and client, for mapping back from small Id, to channel
+	DQRConnectionInfo													m_connectionInfoClient;						// For client
+	unsigned int														m_hostSessionAddress;						// For client
+
+	CRITICAL_SECTION													m_csHostGamertagResolveResults;
+	queue<HostGamertagResolveDetails *>									m_hostGamertagResolveResults;
+
+	void																AddPlayerFailed(Platform::String ^xuid);
+	Platform::String^													RemoveBracesFromGuidString(__in Platform::String^ guid );
+	void																HandleSessionChange( MXSM::MultiplayerSession^ session );
+	MXSM::MultiplayerSession^											WriteSessionHelper(  MXS::XboxLiveContext^ xboxLiveContext,
+																							MXSM::MultiplayerSession^ multiplayerSession,
+																							MXSM::MultiplayerSessionWriteMode writeMode,
+																							HRESULT& hr);
+	MXSM::MultiplayerSessionMember^										GetUserMemberInSession( Windows::Xbox::System::User^ user, MXSM::MultiplayerSession^ session);
+	bool																IsPlayerInSession( Platform::String^ xboxUserId, MXSM::MultiplayerSession^ session, int *smallId );
+
+	WXM::MultiplayerSessionReference^									ConvertToWindowsXboxMultiplayerSessionReference( MXSM::MultiplayerSessionReference^ sessionRef);
+	MXSM::MultiplayerSessionReference^									ConvertToMicrosoftXboxServicesMultiplayerSessionReference( WXM::MultiplayerSessionReference^ sessionRef );
+
+	void																BytesReceived(int smallId, BYTE *bytes, int byteCount);
+	void																BytesReceivedInternal(DQRConnectionInfo *connectionInfo, unsigned int sessionAddress, BYTE *bytes, int byteCount);
+	void																SendBytes(int smallId, BYTE *bytes, int byteCount);
+	int																	GetQueueSizeBytes();
+	int																	GetQueueSizeMessages();
+	void																SendBytesRaw(int smallId, BYTE *bytes, int byteCount, bool reliableAndSequential);
+	void																SendBytesChat(unsigned int address, BYTE *bytes, int byteCount, bool reliable, bool sequential, bool broadcast);
+	
+	bool																AddRoomSyncPlayer(DQRNetworkPlayer *pPlayer, unsigned int sessionAddress, int channel);
+	void																RemoveRoomSyncPlayersWithSessionAddress(unsigned int sessionAddress);
+	void																RemoveRoomSyncPlayer(DQRNetworkPlayer *pPlayer);
+	void																UpdateRoomSyncPlayers(RoomSyncData *pNewSyncData);
+	void																SendRoomSyncInfo();
+	void																SendAddPlayerFailed(Platform::String^ xuid);
+	void																SendSmallId(bool reliableAndSequential, int playerMask);
+	void																SendUnassignSmallId(int playerIndex);
+	int																	GetSessionIndexForSmallId(unsigned char smallId);
+	int																	GetSessionIndexAndSmallIdForHost(unsigned char *smallId);
+
+	static void															LogComment( Platform::String^ strText );	
+	static void															LogCommentFormat( LPCWSTR strMsg, ... );
+	static void															LogCommentWithError( Platform::String^ strTest, HRESULT hr );
+
+	static Platform::String^											GetErrorString( HRESULT hr );
+	static Platform::String^											FormatString( LPCWSTR strMsg, ... );
+	static Platform::String^											ConvertHResultToErrorName( HRESULT hr );
+
+	Platform::String^													GetNextSmallIdAsJsonString();
+	static int															_HostGameThreadProc( void* lpParameter );
+	int																	HostGameThreadProc();
+	static int															_LeaveRoomThreadProc( void* lpParameter );
+	int																	LeaveRoomThreadProc();
+	static int															_TidyUpJoinThreadProc( void* lpParameter );
+	int																	TidyUpJoinThreadProc();
+	static int															_UpdateCustomSessionDataThreadProc( void* lpParameter );
+	int																	UpdateCustomSessionDataThreadProc();
+	static int															_CheckInviteThreadProc(void *lpParameter);
+	int																	CheckInviteThreadProc();
+	static int															_RTSDoWorkThread(void* lpParameter);
+	int																	RTSDoWorkThread();
+
+	CRITICAL_SECTION													m_csVecChatPlayers;
+	vector<int>															m_vecChatPlayersJoined;
+public:
+	void																HandleNewPartyFoundForPlayer();
+	void																HandlePlayerRemovedFromParty(int playerMask);
+
+	void																ChatPlayerJoined(int idx);
+	bool																IsReadyToPlayOrIdle();
+	void																StartGame();
+	void																LeaveRoom();
+	void																TidyUpFailedJoin();
+
+	static void															SetInviteReceivedFlag();
+	static void															SetPartyProcessJoinParty();
+	static void															SetPartyProcessJoinSession(int bootUserIndex, Platform::String^ bootSessionName, Platform::String^ bootServiceConfig, Platform::String^ bootSessionTemplate);
+
+	void																SendInviteGUI(int quadrant);
+	bool																IsAddingPlayer();
+
+	bool																FriendPartyManagerIsBusy();
+	int																	FriendPartyManagerGetCount();
+	bool																FriendPartyManagerSearch();
+	void																FriendPartyManagerGetSessionInfo(int idx, SessionSearchResult *searchResult);
+	WFC::IVectorView<WXM::UserPartyAssociation^>^						FilterPartiesByPermission(MXS::XboxLiveContext ^context, WFC::IVectorView<WXM::UserPartyAssociation^>^ partyResults);
+
+	bool																JoinPartyFromSearchResult(SessionSearchResult *searchResult, int playerMask);
+	void																CancelJoinPartyFromSearchResult();
+	void																RequestDisplayName(DQRNetworkPlayer *player);
+	void																SetDisplayName(PlayerUID xuid, wstring displayName);
+
+private:
+	__int64																m_playersLeftPartyTime;
+	int																	m_playersLeftParty;
+
+	bool																GetBestPartyUserIndex();
+	C4JThread															*m_GetFriendPartyThread;
+	static int															_GetFriendsThreadProc( void* lpParameter );
+	int																	GetFriendsThreadProc();
+	bool																IsSessionFriendsOfFriends(MXSM::MultiplayerSession^ session);
+	bool																GetGameSessionData(MXSM::MultiplayerSession^ session, void *gameSessionData);
+
+public:
+	static Platform::Collections::Vector<Platform::String^>^			GetFriends(); 
+
+private:
+	SessionSearchResult													*m_sessionSearchResults;
+	int																	m_sessionResultCount;
+	bool																m_cancelJoinFromSearchResult;
+
+	map<wstring, wstring>												m_displayNames; // Player display names by gamertag
+
+
+
+	typedef enum
+	{
+		DNM_PARTY_PROCESS_NONE,
+		DNM_PARTY_PROCESS_JOIN_PARTY,
+		DNM_PARTY_PROCESS_JOIN_SPECIFIED
+	} ePartyProcessType;
+	static int															m_bootUserIndex;
+	static ePartyProcessType											m_partyProcess;
+	static wstring														m_bootSessionName;
+	static wstring														m_bootServiceConfig;
+	static wstring														m_bootSessionTemplate;
+	static bool															m_inviteReceived;
+
+	static DQRNetworkManager											*s_pDQRManager;
+
+	static void															GetProfileCallback(LPVOID pParam, Microsoft::Xbox::Services::Social::XboxUserProfile^ profile);
+
+	// Forced signout
+	bool m_handleForcedSignOut;
+
+	void CheckForcedSignOut();
+	void HandleForcedSignOut();
+
+	unsigned int														m_RTS_Stat_totalBytes;
+	unsigned int														m_RTS_Stat_totalSends;
+
+	void																UpdateRTSStats();
+
+	// Incoming messages - to be called from the main thread, to get incoming messages from the RTS work thread
+	void																ProcessRTSMessagesIncoming();
+	void																Process_RTS_MESSAGE_DATA_RECEIVED(RTS_Message &message);
+	void																Process_RTS_MESSAGE_DATA_RECEIVED_CHAT(RTS_Message &message);
+	void																Process_RTS_MESSAGE_ADDED_SESSION_ADDRESS(RTS_Message &message);
+	void																Process_RTS_MESSAGE_REMOVED_SESSION_ADDRESS(RTS_Message &message);
+	void																Process_RTS_MESSAGE_STATUS_ACTIVE(RTS_Message &message);
+	void																Process_RTS_MESSAGE_STATUS_TERMINATED(RTS_Message &message);
+
+	// Outgoing messages - to be called from the RTS work thread, to process requests from the main thread
+	
+	void																ProcessRTSMessagesOutgoing();
+	void																Process_RTS_MESSAGE_START_CLIENT(RTS_Message &message);
+	void																Process_RTS_MESSAGE_START_HOST(RTS_Message &message);
+	void																Process_RTS_MESSAGE_TERMINATE(RTS_Message &message);
+	void																Process_RTS_MESSAGE_SEND_DATA(RTS_Message &message);
+
+	// These methods are called from the main thread, to put an outgoing message onto the queue to be processed by these previous methods
+	void																RTS_StartCient();
+	void																RTS_StartHost();
+	void																RTS_Terminate();
+	void																RTS_SendData(unsigned char *pucData, unsigned int dataSize, unsigned int sessionAddress, bool reliable, bool sequential, bool coalesce, bool includeMode, bool gameChannel );
+
+};
+
+// Class defining interface to be implemented for class that handles callbacks
+class IDQRNetworkManagerListener
+{
+public:
+	virtual void HandleDataReceived(DQRNetworkPlayer *playerFrom, DQRNetworkPlayer *playerTo, unsigned char *data, unsigned int dataSize) = 0;
+	virtual void HandlePlayerJoined(DQRNetworkPlayer *player) = 0;
+	virtual void HandlePlayerLeaving(DQRNetworkPlayer *player) = 0;
+	virtual void HandleStateChange(DQRNetworkManager::eDQRNetworkManagerState oldState, DQRNetworkManager::eDQRNetworkManagerState newState) = 0;
+//	virtual void HandleResyncPlayerRequest(DQRNetworkPlayer **aPlayers) = 0;
+	virtual void HandleAddLocalPlayerFailed(int idx, bool serverFull) = 0;
+	virtual void HandleDisconnect(bool bLostRoomOnly) = 0;
+	virtual void HandleInviteReceived(int playerIndex, DQRNetworkManager::SessionInfo *pInviteInfo) = 0;
+	virtual bool IsSessionJoinable() = 0;
+};