Code/CryPlugins/CryLobby/Module/DurangoLive/CryDurangoLiveLobby.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "CryDurangoLiveLobby.h"
   5 #include <CryCore/TypeInfo_impl.h>
   6
   7 #if USE_DURANGOLIVE
   8
   9 using namespace ABI::Windows::Foundation;
  10 using namespace ABI::Windows::Storage::Streams;
  11 using namespace Microsoft::WRL;
  12 using namespace ABI::Windows::Xbox::Networking;
  13 using namespace ABI::Windows::Xbox::System;
  14
  15         #define DURANGO_DEFAULT_PORT           49150
  16
  17         #define TDN_GET_USER_PRIVILEGES_RESULT 0
  18
  19 ECryLobbyError CryDurangoLiveLobbyGetErrorFromDurangoLive(HRESULT error)
  20 {
  21         NetLog("[Lobby] eCLE_InternalError: Durango Live Error %d %x", error, error);
  22         return eCLE_InternalError;
  23 }
  24
  25 CCryDurangoLiveLobbyService::CCryDurangoLiveLobbyService(CCryLobby* pLobby, ECryLobbyService service)
  26         : CCryLobbyService(pLobby, service)
  27         , m_titleID(0)
  28 {
  29 }
  30
  31 CCryDurangoLiveLobbyService::~CCryDurangoLiveLobbyService()
  32 {
  33 }
  34
  35 ECryLobbyError CCryDurangoLiveLobbyService::Initialise(ECryLobbyServiceFeatures features, CryLobbyServiceCallback pCB)
  36 {
  37         ECryLobbyError ret = CCryLobbyService::Initialise(features, pCB);
  38
  39         if ((ret == eCLE_Success) && (m_pTCPServiceFactory == NULL) && (features & eCLSO_TCPService))
  40         {
  41                 m_pTCPServiceFactory = new CCryTCPServiceFactory();
  42
  43                 if (m_pTCPServiceFactory)
  44                 {
  45                         ret = m_pTCPServiceFactory->Initialise("Scripts/Network/TCPServices.xml", CCryTCPServiceFactory::k_defaultMaxSockets);
  46                 }
  47                 else
  48                 {
  49                         return eCLE_OutOfMemory;
  50                 }
  51         }
  52
  53         if (features & eCLSO_Base)
  54         {
  55                 SConfigurationParams neededInfo[2] = {
  56                         { CLCC_LIVE_TITLE_ID,          { NULL }
  57                         },{ CLCC_LIVE_SERVICE_CONFIG_ID, { NULL }
  58                         }
  59                 };
  60
  61                 m_pLobby->GetConfigurationInformation(neededInfo, CRY_ARRAY_COUNT(neededInfo));
  62
  63                 m_titleID = neededInfo[0].m_32;
  64                 m_serviceConfigId.Set(reinterpret_cast<LPCWSTR>(neededInfo[1].m_pData));
  65         }
  66
  67         #if USE_CRY_MATCHMAKING
  68         if ((ret == eCLE_Success) && (m_pMatchmaking == NULL) && (features & eCLSO_Matchmaking))
  69         {
  70                 m_pMatchmaking = new CCryDurangoLiveMatchMaking(m_pLobby, this, m_service);
  71
  72                 if (m_pMatchmaking)
  73                 {
  74                         ret = m_pMatchmaking->Initialise();
  75                 }
  76                 else
  77                 {
  78                         ret = eCLE_OutOfMemory;
  79                 }
  80         }
  81         #endif // USE_CRY_MATCHMAKING
  82
  83         #if USE_CRY_ONLINE_STORAGE
  84         if ((ret == eCLE_Success) && (m_pOnlineStorage == NULL) && (features & eCLSO_OnlineStorage))
  85         {
  86                 m_pOnlineStorage = new CCryDurangoLiveOnlineStorage(m_pLobby, this);
  87                 if (m_pOnlineStorage)
  88                 {
  89                         ret = m_pOnlineStorage->Initialise();
  90                 }
  91                 else
  92                 {
  93                         ret = eCLE_OutOfMemory;
  94                 }
  95         }
  96         #endif // USE_CRY_ONLINE_STORAGE
  97
  98         if ((ret == eCLE_Success) && (m_pLobbyUI == NULL) && (features & eCLSO_LobbyUI))
  99         {
 100                 m_pLobbyUI = new CCryDurangoLiveLobbyUI(m_pLobby, this);
 101
 102                 if (m_pLobbyUI)
 103                 {
 104                         ret = m_pLobbyUI->Initialise();
 105                 }
 106                 else
 107                 {
 108                         ret = eCLE_OutOfMemory;
 109                 }
 110         }
 111
 112         if (ret == eCLE_Success)
 113         {
 114                 if (features & eCLSO_Base)
 115                 {
 116                         m_pLobby->SetServicePacketEnd(m_service, eDurangoLivePT_EndType);
 117                 }
 118         }
 119         else
 120         {
 121                 Terminate(features, NULL);
 122         }
 123
 124         if (pCB)
 125         {
 126                 pCB(ret, m_pLobby, m_service);
 127         }
 128
 129         NetLog("[Lobby] Durango Live Initialise error %d", ret);
 130
 131         return ret;
 132 }
 133
 134 ECryLobbyError CCryDurangoLiveLobbyService::Terminate(ECryLobbyServiceFeatures features, CryLobbyServiceCallback pCB)
 135 {
 136         ECryLobbyError ret = CCryLobbyService::Terminate(features, pCB);
 137
 138         if (m_pTCPServiceFactory && (features & eCLSO_TCPService))
 139         {
 140                 ECryLobbyError error = m_pTCPServiceFactory->Terminate(false);
 141                 m_pTCPServiceFactory = NULL;
 142
 143                 if (ret == eCLE_Success)
 144                 {
 145                         ret = error;
 146                 }
 147         }
 148
 149         #if USE_CRY_MATCHMAKING
 150         if (m_pMatchmaking && (features & eCLSO_Matchmaking))
 151         {
 152                 ECryLobbyError error = m_pMatchmaking->Terminate();
 153                 m_pMatchmaking = NULL;
 154
 155                 if (ret == eCLE_Success)
 156                 {
 157                         ret = error;
 158                 }
 159         }
 160         #endif // USE_CRY_MATCHMAKING
 161
 162         #if USE_CRY_ONLINE_STORAGE
 163         if (m_pOnlineStorage && (features & eCLSO_OnlineStorage))
 164         {
 165                 ECryLobbyError error = m_pOnlineStorage->Terminate();
 166                 m_pOnlineStorage = NULL;
 167
 168                 if (ret == eCLE_Success)
 169                 {
 170                         ret = error;
 171                 }
 172         }
 173         #endif // USE_CRY_ONLINE_STORAGE
 174
 175         if (m_pLobbyUI && (features & eCLSO_LobbyUI))
 176         {
 177                 ECryLobbyError error = m_pLobbyUI->Terminate();
 178                 m_pLobbyUI = NULL;
 179
 180                 if (ret == eCLE_Success)
 181                 {
 182                         ret = error;
 183                 }
 184         }
 185
 186         if (pCB)
 187         {
 188                 pCB(ret, m_pLobby, m_service);
 189         }
 190
 191         return ret;
 192 }
 193
 194 void CCryDurangoLiveLobbyService::Tick(CTimeValue tv)
 195 {
 196         if (m_pLobby->MutexTryLock())
 197         {
 198         #if USE_CRY_MATCHMAKING
 199                 if (m_pMatchmaking)
 200                 {
 201                         m_pMatchmaking->Tick(tv);
 202                 }
 203         #endif // USE_CRY_MATCHMAKING
 204
 205         #if USE_CRY_ONLINE_STORAGE
 206                 if (m_pOnlineStorage)
 207                 {
 208                         m_pOnlineStorage->Tick(tv);
 209                 }
 210         #endif // USE_CRY_ONLINE_STORAGE
 211
 212                 if (m_pLobbyUI)
 213                 {
 214                         m_pLobbyUI->Tick(tv);
 215                 }
 216
 217                 m_pLobby->MutexUnlock();
 218         }
 219
 220         if (m_pTCPServiceFactory)
 221         {
 222                 m_pTCPServiceFactory->Tick(tv);
 223         }
 224 }
 225
 226 void CCryDurangoLiveLobbyService::OnPacket(const TNetAddress& addr, CCryLobbyPacket* pPacket)
 227 {
 228         #if USE_CRY_MATCHMAKING
 229         if (m_pMatchmaking)
 230         {
 231                 m_pMatchmaking->OnPacket(addr, pPacket);
 232         }
 233         #endif // USE_CRY_MATCHMAKING
 234 }
 235
 236 void CCryDurangoLiveLobbyService::OnError(const TNetAddress& addr, ESocketError error, CryLobbySendID sendID)
 237 {
 238         #if USE_CRY_MATCHMAKING
 239         if (m_pMatchmaking)
 240         {
 241                 m_pMatchmaking->OnError(addr, error, sendID);
 242         }
 243         #endif // USE_CRY_MATCHMAKING
 244 }
 245
 246 void CCryDurangoLiveLobbyService::OnSendComplete(const TNetAddress& addr, CryLobbySendID sendID)
 247 {
 248         #if USE_CRY_MATCHMAKING
 249         if (m_pMatchmaking)
 250         {
 251                 m_pMatchmaking->OnSendComplete(addr, sendID);
 252         }
 253         #endif // USE_CRY_MATCHMAKING
 254 }
 255
 256 CryUserID CCryDurangoLiveLobbyService::GetUserID(uint32 user)
 257 {
 258         return CryUserInvalidID;
 259 }
 260
 261 void CCryDurangoLiveLobbyService::StartTaskRunning(CryLobbyServiceTaskID lsTaskID)
 262 {
 263         LOBBY_AUTO_LOCK;
 264
 265         STask* pTask = GetTask(lsTaskID);
 266
 267         if (pTask->used)
 268         {
 269                 pTask->running = true;
 270
 271                 switch (pTask->startedTask)
 272                 {
 273                 case eT_GetUserPrivileges:
 274                         StartGetUserPrivileges(lsTaskID);
 275                         break;
 276                 }
 277         }
 278 }
 279
 280 void CCryDurangoLiveLobbyService::StopTaskRunning(CryLobbyServiceTaskID lsTaskID)
 281 {
 282         STask* pTask = GetTask(lsTaskID);
 283
 284         if (pTask->used)
 285         {
 286                 pTask->running = false;
 287
 288                 TO_GAME_FROM_LOBBY(&CCryDurangoLiveLobbyService::EndTask, this, lsTaskID);
 289         }
 290 }
 291
 292 void CCryDurangoLiveLobbyService::EndTask(CryLobbyServiceTaskID lsTaskID)
 293 {
 294         LOBBY_AUTO_LOCK;
 295
 296         STask* pTask = GetTask(lsTaskID);
 297
 298         if (pTask->used)
 299         {
 300                 if (pTask->pCB)
 301                 {
 302                         switch (pTask->startedTask)
 303                         {
 304                         case eT_GetUserPrivileges:
 305                                 ((CryLobbyPrivilegeCallback)pTask->pCB)(pTask->lTaskID, pTask->error, pTask->dataNum[TDN_GET_USER_PRIVILEGES_RESULT], pTask->pCBArg);
 306                                 break;
 307                         }
 308                 }
 309
 310                 if (pTask->error != eCLE_Success)
 311                 {
 312                         NetLog("[Lobby] Lobby Service EndTask %d Result %d", pTask->startedTask, pTask->error);
 313                 }
 314
 315                 FreeTask(lsTaskID);
 316         }
 317 }
 318
 319 ECryLobbyError CCryDurangoLiveLobbyService::GetUserPrivileges(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyPrivilegeCallback pCB, void* pCBArg)
 320 {
 321         ECryLobbyError error;
 322         CryLobbyServiceTaskID tid;
 323
 324         LOBBY_AUTO_LOCK;
 325
 326         error = StartTask(eT_GetUserPrivileges, user, false, &tid, pTaskID, (void*)pCB, pCBArg);
 327
 328         if (error == eCLE_Success)
 329         {
 330                 FROM_GAME_TO_LOBBY(&CCryDurangoLiveLobbyService::StartTaskRunning, this, tid);
 331         }
 332
 333         return error;
 334 }
 335
 336 void CCryDurangoLiveLobbyService::StartGetUserPrivileges(CryLobbyServiceTaskID lsTaskID)
 337 {
 338         STask* pTask = GetTask(lsTaskID);
 339         uint32 result = 0;
 340
 341         if (m_pLobby->GetInternalSocket(m_service))
 342         {
 343         }
 344         else
 345         {
 346                 UpdateTaskError(lsTaskID, eCLE_InternalError);
 347         }
 348
 349         pTask->dataNum[TDN_GET_USER_PRIVILEGES_RESULT] = result;
 350
 351         StopTaskRunning(lsTaskID);
 352 }
 353
 354 ECryLobbyError CCryDurangoLiveLobbyService::GetSystemTime(uint32 user, SCrySystemTime* pSystemTime)
 355 {
 356         memset(pSystemTime, 0, sizeof(SCrySystemTime));
 357
 358         ECryLobbyError error = eCLE_Success;
 359         SYSTEMTIME systemTime;
 360         ::GetSystemTime(&systemTime);
 361
 362         pSystemTime->m_Year = systemTime.wYear;
 363         pSystemTime->m_Month = static_cast<uint8>(systemTime.wMonth);
 364         pSystemTime->m_Day = static_cast<uint8>(systemTime.wDay);
 365         pSystemTime->m_Hour = static_cast<uint8>(systemTime.wHour);
 366         pSystemTime->m_Minute = static_cast<uint8>(systemTime.wMinute);
 367         pSystemTime->m_Second = static_cast<uint8>(systemTime.wSecond);
 368
 369         return error;
 370 }
 371
 372 void CCryDurangoLiveLobbyService::GetSocketPorts(uint16& connectPort, uint16& listenPort)
 373 {
 374         connectPort = DURANGO_DEFAULT_PORT;
 375         listenPort = DURANGO_DEFAULT_PORT;
 376 }
 377
 378 #endif // USE_DURANGOLIVE