749 lines
23 KiB
C++
749 lines
23 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// (c) Copyright, Ubisoft Entertainment Inc. || Created by Harbour //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#include "ubiservices/sessionManager.h"
|
|
#include "ubiservices/core/configs/configpriv.h"
|
|
#include "ubiservices/core/extensions/enumeration.h"
|
|
#include "ubiservices/core/helpers/instancesManager.h"
|
|
#include "ubiservices/core/log/remoteLoggerSdk.h"
|
|
#include "ubiservices/core/notifications/notificationSource.inl" // INTENDED
|
|
#include "ubiservices/core/tasks/asyncResultInternal.h"
|
|
#if defined(US_TARGET_XONE)
|
|
#include "ubiservices/core/tasks/xone/xboxLiveContext.h"
|
|
#endif
|
|
#include "ubiservices/facadeInternal.h"
|
|
#include "ubiservices/services/authentication/authenticationClient.h"
|
|
#if !defined(US_SDK_SERVER)
|
|
#include "ubiservices/services/authentication/playerCredentials.h"
|
|
#endif
|
|
#if defined(US_MODULE_CLUB)
|
|
#include "ubiservices/services/club/clubClient.h"
|
|
#include "ubiservices/services/club/clubNotification.h"
|
|
#endif
|
|
#include "ubiservices/services/parameters/featureSwitchId.h"
|
|
#include "ubiservices/services/parameters/featureSwitchHelper.h"
|
|
#include "ubiservices/services/parameters/parametersInfoHelper.h"
|
|
#include "ubiservices/services/notification/notificationClient.h"
|
|
#include "ubiservices/services/notification/notificationUbiServices.h"
|
|
#include "ubiservices/services/notification/notificationCustom.h"
|
|
#include "ubiservices/services/notification/standardTypes.h"
|
|
#include "ubiservices/services/remoteLog/remoteLoggerCustom.h"
|
|
#if !defined(US_SDK_SERVER)
|
|
#include "ubiservices/services/secondaryStore/secondaryStoreClient.h"
|
|
#include "ubiservices/services/secondaryStore/secondaryStoreNotification.h"
|
|
#include "ubiservices/services/websocket/websocketConnection.h"
|
|
#endif
|
|
|
|
namespace US_NS {;
|
|
|
|
SessionManager::RestPeriod::RestPeriod()
|
|
: m_chrono(ClockSteady::getNanoFromSeconds(1000))
|
|
{
|
|
}
|
|
|
|
SessionManager::SessionManager(FacadeInternal& facade)
|
|
: m_facade(facade)
|
|
, m_sessionInfoSnapshot()
|
|
, m_jobManagerExtendSession(1, "AuthenticationClient-ExtendSession")
|
|
, m_extendSessionResult("SessionManager async #1")
|
|
, m_isFirstCallToJobLogin(true)
|
|
// The following results are used to prevent parallel execution of CreateSession and PopUnsentEvent
|
|
, m_createSessionResult("SessionManager/CreateSessionResult")
|
|
, m_executionBlockers()
|
|
#if !defined(US_SDK_SERVER)
|
|
, m_webSocketInit(facade)
|
|
, m_isEventEndOfGame(false)
|
|
#if defined(US_MODULE_STORE)
|
|
, m_sessionManagerStore(facade)
|
|
#endif
|
|
#if defined(US_MODULE_CLUB)
|
|
, m_sessionManagerClub()
|
|
#endif // defined(US_MODULE_CLUB)
|
|
#if defined(US_TARGET_SWITCH)
|
|
, m_isUserHandleSet(false)
|
|
#elif defined(US_TARGET_PS4) || defined(US_TARGET_PS5)
|
|
, m_isUserIdSet(false)
|
|
#elif defined(US_TARGET_STADIA)
|
|
, m_isPlayerIdSet(false)
|
|
#endif
|
|
, m_sessionManagerPopulations(facade)
|
|
, m_connectionMetaData(String())
|
|
, m_popUnsentEventsResult("SessionManager/PopUnsentEvenResult")
|
|
, m_concurrentConnectRestPeriodInProgress(false)
|
|
#else
|
|
, m_isCertificatePublicKeySet(false)
|
|
#endif
|
|
{
|
|
}
|
|
|
|
SessionManager::~SessionManager()
|
|
{
|
|
}
|
|
|
|
void SessionManager::init()
|
|
{
|
|
#if !defined(US_SDK_SERVER) && defined(US_MODULE_STORE)
|
|
m_sessionManagerStore.init();
|
|
#endif
|
|
}
|
|
|
|
bool SessionManager::hasValidSessionInfoInternal() const
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
return m_sessionInfo.isValid();
|
|
}
|
|
|
|
const SessionInfo& SessionManager::getSessionInfoRO() const
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
return m_sessionInfo;
|
|
}
|
|
|
|
void SessionManager::invalidateSessionInfo()
|
|
{
|
|
US_PERF_TASK_FUNC();
|
|
|
|
resetSessionInfo();
|
|
|
|
if (m_extendSessionResult.isProcessing())
|
|
{
|
|
m_extendSessionResult.cancel(); // Stop extend session job
|
|
}
|
|
}
|
|
|
|
void SessionManager::resetSessionInfo()
|
|
{
|
|
m_sessionInfo = SessionInfo(m_sessionInfo.m_pImpl->m_parametersApplicationReady, m_sessionInfo.m_pImpl->m_parametersSpaceReady);
|
|
m_sessionInfoSnapshot = US_NEW(SessionInfo, m_sessionInfo); // Refresh snapshot with new changes
|
|
}
|
|
|
|
void SessionManager::setSessionInfo(const SessionInfo& sessionInfo, bool restartJob)
|
|
{
|
|
US_PERF_TASK_FUNC();
|
|
|
|
#if !defined(US_SDK_SERVER)
|
|
US_ASSERT(sessionInfo.m_pImpl->m_playerCredentials.isValid(), "An invalid SessionInfo has been passed");
|
|
#endif
|
|
|
|
const bool parametersApplicationReadySaved = m_sessionInfo.m_pImpl->m_parametersApplicationReady;
|
|
const bool parametersSpaceReadySaved = m_sessionInfo.m_pImpl->m_parametersSpaceReady;
|
|
m_sessionInfo = sessionInfo;
|
|
m_sessionInfo.m_pImpl->m_parametersApplicationReady = parametersApplicationReadySaved;
|
|
m_sessionInfo.m_pImpl->m_parametersSpaceReady = parametersSpaceReadySaved;
|
|
|
|
m_sessionInfoSnapshot = US_NEW(SessionInfo, m_sessionInfo); // Refresh snapshot with new changes
|
|
|
|
#if !defined(US_SDK_SERVER)
|
|
if (sessionInfo.getProfileId().isValid()) //profileInfo is not sent while extending the session.
|
|
{
|
|
m_storedProfileId = sessionInfo.getProfileId();
|
|
}
|
|
#endif
|
|
|
|
m_facade.getAuthenticationClient().m_notificationsAuthentication->m_impl->m_notificationsQueue->pushNotification(
|
|
AuthenticationNotification(AuthenticationNotificationType::SessionInfoChanged));
|
|
|
|
if (restartJob)
|
|
{
|
|
restartExtendSessionJob();
|
|
}
|
|
}
|
|
|
|
void SessionManager::restartExtendSessionJob()
|
|
{
|
|
US_PERF_TASK_FUNC();
|
|
|
|
if(getSwitchesContent().isEnabled(FeatureSwitchId::ExtendSession) && hasValidSessionInfoInternal())
|
|
{
|
|
US_ASSERT(m_sessionInfo.isValid(), "This method shall only be called with a session instance");
|
|
|
|
m_extendSessionResult.cancel(); // Stop extend session job
|
|
|
|
AsyncResultInternal<Empty> result("restartExtendSessionJob");
|
|
const ClockSteady::TTimeMilli ticketTTL =
|
|
static_cast<ClockSteady::TTimeMilli>(m_sessionInfo.m_pImpl->m_localExpirationTime - ClockSteady::getTimeMilli());
|
|
m_jobManagerExtendSession.launch(result, US_NEW(JobExtendSession, result, m_facade, ticketTTL));
|
|
m_extendSessionResult = result;
|
|
}
|
|
}
|
|
|
|
Environment SessionManager::getDetectedEnvironment(const SessionInfo* sessionInfo) const
|
|
{
|
|
US_PERF_TASK_FUNC();
|
|
|
|
// Search for the environment in session info first
|
|
if (sessionInfo != nullptr && sessionInfo->isValid())
|
|
{
|
|
return sessionInfo->getEnvironmentCode();
|
|
}
|
|
|
|
// If the createSession (or other methods like createAccount) failed, we may have an environment set despite not
|
|
// having a valid session. This is useful when trying to get the parameters from the correct environment namely
|
|
if (m_environmentOnError.isSpecified())
|
|
{
|
|
return m_environmentOnError.value();
|
|
}
|
|
|
|
// Search for the environment in instance manager
|
|
const InstancesManager* im = InstancesManager::getInstance();
|
|
if (im != nullptr)
|
|
{
|
|
return im->getEnvironment();
|
|
}
|
|
|
|
US_LOG(LogLevel::Error, LogCategory::Core, "Failed to find the current environment. Returning default value (PROD).");
|
|
return Environment::Prod;
|
|
}
|
|
|
|
void SessionManager::setEnvironmentOnError(Environment environment)
|
|
{
|
|
m_environmentOnError = environment;
|
|
}
|
|
|
|
void SessionManager::unsetEnvironmentOnError()
|
|
{
|
|
m_environmentOnError.clear();
|
|
}
|
|
|
|
void SessionManager::resetParametersInfo()
|
|
{
|
|
US_PERF_TASK_FUNC();
|
|
|
|
m_parameters = ParametersInfo();
|
|
m_sessionInfo.m_pImpl->m_parametersApplicationReady = false;
|
|
m_sessionInfo.m_pImpl->m_parametersSpaceReady = false;
|
|
|
|
m_sessionInfoSnapshot = US_NEW(SessionInfo, m_sessionInfo); // Refresh snapshot with new changes
|
|
}
|
|
|
|
void SessionManager::updateParametersSettings()
|
|
{
|
|
US_PERF_TASK_FUNC();
|
|
|
|
// No internal logs for S2S
|
|
#if !defined(US_SDK_SERVER)
|
|
// Configure remote logger internal
|
|
const ParametersRemoteLogsInternal& remoteLogConfigInternal = m_parameters.m_remoteLogParametersInternal;
|
|
m_facade.getRemoteLoggerSdk().setLogLevelByCategory(remoteLogConfigInternal.m_logLevelByCategory);
|
|
m_facade.getRemoteLoggerSdk().setTextMaxLength(remoteLogConfigInternal.m_textMaxLength);
|
|
#endif
|
|
|
|
// Configure remote logger exposed
|
|
const ParametersRemoteLogsGame& remoteLogConfigExposed = m_parameters.m_paramsRemoteLogExposed;
|
|
m_facade.getRemoteLoggerCustom().setLogLevelByCategory(remoteLogConfigExposed.m_logLevelByCategory);
|
|
m_facade.getRemoteLoggerCustom().setTextMaxLength(remoteLogConfigExposed.m_textMaxLength);
|
|
m_facade.getRemoteLoggerCustom().setUrl(remoteLogConfigExposed.m_url);
|
|
|
|
HttpRetryConfig retryConfigCustom(m_parameters.m_paramsSettingsHttpGame.m_maxCount);
|
|
retryConfigCustom.m_retryParam = HttpRetryConfig::RetryParam(
|
|
m_parameters.m_paramsSettingsHttpGame.m_retryInitialDelayMsec.getCount(),
|
|
m_parameters.m_paramsSettingsHttpGame.m_retryIncrementFactorMsec.getCount(),
|
|
m_parameters.m_paramsSettingsHttpGame.m_retryRandomDelayMsec.getCount(),
|
|
m_parameters.m_paramsSettingsHttpGame.m_retryMaxDelayMsec.getCount());
|
|
retryConfigCustom.m_timeoutParam = HttpRetryConfig::TimeoutParam(
|
|
m_parameters.m_paramsSettingsHttpGame.m_timeoutInitialDelayMsec.getCount(),
|
|
m_parameters.m_paramsSettingsHttpGame.m_timeoutIncrementFactorMsec.getCount());
|
|
m_facade.getRemoteLoggerCustom().setHttpRetryConfig(retryConfigCustom);
|
|
|
|
m_sessionInfo.m_pImpl->m_parametersApplicationReady = true;
|
|
m_sessionInfo.m_pImpl->m_parametersSpaceReady = true;
|
|
|
|
m_sessionInfoSnapshot = US_NEW(SessionInfo, m_sessionInfo); // Refresh snapshot with new changes
|
|
}
|
|
|
|
bool SessionManager::areParametersGroupsReady() const
|
|
{
|
|
return m_sessionInfo.m_pImpl->m_parametersApplicationReady &&
|
|
m_sessionInfo.m_pImpl->m_parametersSpaceReady;
|
|
}
|
|
|
|
bool SessionManager::isParametersApplicationReady() const
|
|
{
|
|
return m_sessionInfo.m_pImpl->m_parametersApplicationReady;
|
|
}
|
|
|
|
bool SessionManager::isParametersSpaceReady() const
|
|
{
|
|
return m_sessionInfo.m_pImpl->m_parametersSpaceReady;
|
|
}
|
|
|
|
const ParametersInfo& SessionManager::getParametersInfo() const
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
//ScopedCS cs(*m_criticalSection);
|
|
return m_parameters;
|
|
}
|
|
|
|
ParametersInfo& SessionManager::getParametersInfoRW()
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
//ScopedCS cs(*m_criticalSection);
|
|
return m_parameters;
|
|
}
|
|
|
|
bool SessionManager::setParametersGroupApplication(const ParametersGroupInfoMap& parametersGroupApplication)
|
|
{
|
|
const bool isSuccess = m_parameters.setParametersApplication(parametersGroupApplication, m_applicationSwitches);
|
|
// The feature switches might have failed, but we can do a best effort regardless.
|
|
m_killSwitch = FeatureSwitchHelper::mergeFeatureSwitches(m_applicationSwitches, m_spaceSwitches);
|
|
return isSuccess;
|
|
}
|
|
|
|
bool SessionManager::setParametersGroupSpace(const ParametersGroupInfoMap& parametersGroupSpace)
|
|
{
|
|
const bool isSuccess = m_parameters.setParametersSpace(parametersGroupSpace, m_spaceSwitches);
|
|
// The feature switches might have failed, but we can do a best effort regardless.
|
|
m_killSwitch = FeatureSwitchHelper::mergeFeatureSwitches(m_applicationSwitches, m_spaceSwitches);
|
|
|
|
updateParametersSettings();
|
|
m_sessionInfo.m_pImpl->m_parametersSpaceReady = true;
|
|
|
|
return isSuccess;
|
|
}
|
|
|
|
Vector<String>& SessionManager::getParametersGroupListApplicationRW()
|
|
{
|
|
return m_parametersGroupListApplication;
|
|
}
|
|
|
|
const Vector<String>& SessionManager::getParametersGroupListApplication() const
|
|
{
|
|
return m_parametersGroupListApplication;
|
|
}
|
|
|
|
Vector<String>& SessionManager::getParametersGroupListSpaceRW()
|
|
{
|
|
return m_parametersGroupListSpace;
|
|
}
|
|
|
|
const Vector<String>& SessionManager::getParametersGroupListSpace() const
|
|
{
|
|
return m_parametersGroupListSpace;
|
|
}
|
|
|
|
const FeatureSwitch& SessionManager::getSwitchesContent() const
|
|
{
|
|
return m_killSwitch;
|
|
}
|
|
FeatureSwitch& SessionManager::getSwitchesContentRW()
|
|
{
|
|
return m_killSwitch;
|
|
}
|
|
void SessionManager::setSwitchesContent(const FeatureSwitch& switches)
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
m_killSwitch = switches;
|
|
}
|
|
void SessionManager::enableSwitch(FeatureSwitchId feature, bool enableState)
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
m_killSwitch.enable(feature, enableState);
|
|
}
|
|
|
|
SessionManager::RestPeriod& SessionManager::getRestPeriod()
|
|
{
|
|
return m_restPeriod;
|
|
}
|
|
|
|
const SessionManagerOverlay& SessionManager::getSessionManagerOverlay() const
|
|
{
|
|
return m_sessionManagerOverlay;
|
|
}
|
|
|
|
SessionManagerOverlay& SessionManager::getSessionManagerOverlayRW()
|
|
{
|
|
return m_sessionManagerOverlay;
|
|
}
|
|
|
|
bool SessionManager::getIsFirstCallToLogin()
|
|
{
|
|
return m_isFirstCallToJobLogin;
|
|
}
|
|
|
|
void SessionManager::setFirstCallToLoginDone()
|
|
{
|
|
m_isFirstCallToJobLogin = false;
|
|
}
|
|
|
|
bool SessionManager::isLogEnabledSdk(RemoteLogLevel::Enum logLevel, LogCategory logCategory) const
|
|
{
|
|
return m_facade.getRemoteLoggerSdk().isLogEnabled(logLevel, logCategory);
|
|
}
|
|
|
|
bool SessionManager::isLogEnabledCustom(RemoteLogLevel::Enum logLevel, const String& logCategory) const
|
|
{
|
|
return m_facade.getRemoteLoggerCustom().isLogEnabled(logLevel, logCategory);
|
|
}
|
|
|
|
void SessionManager::setWaitRemoteLogCompletionOnDeleteSessionParameter(bool state)
|
|
{
|
|
m_parameters.m_paramsSettings.m_waitRemoteLogCompletionOnDeleteSession = state;
|
|
}
|
|
|
|
SpaceId SessionManager::getWorkingSpaceId() const
|
|
{
|
|
return m_workingSpaceId;
|
|
}
|
|
|
|
void SessionManager::setWorkingSpaceId(const SpaceId& workingSpaceid)
|
|
{
|
|
m_workingSpaceId = workingSpaceid;
|
|
}
|
|
|
|
bool SessionManager::updateWorkingSpaceId(const Map<String, ParametersGroupInfo>& parameters)
|
|
{
|
|
return m_parameters.updateWorkingSpaceId(m_workingSpaceId, parameters);
|
|
}
|
|
|
|
AsyncResult<Empty>& SessionManager::getCreateSessionAsyncResultRW()
|
|
{
|
|
return m_createSessionResult;
|
|
}
|
|
ExecutionBlocker& SessionManager::getExecutionBlocker(MutualExecutionBlocker::BlockingCallType blockingCallType)
|
|
{
|
|
return m_executionBlockers[blockingCallType];
|
|
}
|
|
|
|
void SessionManager::reduceSessionDuration(uint64 expirationTimeMs) //TODO: REMOVE TEST-ONLY CODE FROM SDK
|
|
{
|
|
US_ASSERT(m_sessionInfo.isValid(), "State failure");
|
|
m_sessionInfo.m_pImpl->m_localExpirationTime = expirationTimeMs;
|
|
|
|
//m_sessionInfoSnapshot = US_NEW(SessionInfo, m_sessionInfo); // Refresh snapshot with new changes // TODO: REVIEW
|
|
restartExtendSessionJob();
|
|
}
|
|
|
|
#if !defined(US_SDK_SERVER)
|
|
///////////////////////////////////////////////////////////////////////
|
|
// WebSocketInit
|
|
SessionManager::WebSocketInit::WebSocketInit(FacadeInternal& facade)
|
|
: m_facade(facade)
|
|
, m_result("SessionManager async #2")
|
|
, m_manager(1u, "AuthenticationClient-InitWebSocket")
|
|
{
|
|
}
|
|
|
|
void SessionManager::WebSocketInit::launchInitLogin()
|
|
{
|
|
AsyncResultInternal<Empty> initResult("WebSocketInit/Login");
|
|
m_manager.launch(initResult, US_NEW(JobInitWebsocket, initResult, m_facade, m_facade.getManager().getParametersInfo().m_paramsSettingsWebsocketInternal));
|
|
m_result = initResult;
|
|
}
|
|
|
|
void SessionManager::WebSocketInit::launchInitResume()
|
|
{
|
|
AsyncResultInternal<Empty> initResult("WebSocketInit/Resume");
|
|
m_manager.launch(initResult, US_NEW(JobInitWebsocket, initResult, m_facade, m_facade.getManager().getParametersInfo().m_paramsSettingsWebsocketInternal));
|
|
m_result = initResult;
|
|
}
|
|
|
|
void SessionManager::WebSocketInit::cancelWebsocketInit()
|
|
{
|
|
m_result.cancel();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
SessionManager::WebSocketInit& SessionManager::getWebSocketInitializer()
|
|
{
|
|
return m_webSocketInit;
|
|
}
|
|
|
|
bool SessionManager::hasDefaultSessionInfo() const
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
return m_sessionInfo.isDefault();
|
|
}
|
|
|
|
const ProfileId& SessionManager::getStoredProfile() const
|
|
{
|
|
return m_storedProfileId;
|
|
}
|
|
|
|
bool SessionManager::hasNotificationTypeChanged() const
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
return (m_parameters.m_hasNotificationTypeChanged);
|
|
}
|
|
|
|
DurationMilli SessionManager::getNotificationUpdateRandomDelay() const
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
return m_parameters.m_paramsSettings.m_notificationTypesUpdateRandomDelayMsec;
|
|
}
|
|
Vector<String> SessionManager::mergeNotificationTypes(const Vector<String>& types1, const Vector<String>& types2) const
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
|
|
Vector<String> result;
|
|
result.reserve(types1.size() + types2.size());
|
|
result.insert(result.end(), types1.begin(), types1.end());
|
|
result.insert(result.end(), types2.begin(), types2.end());
|
|
|
|
return result;
|
|
}
|
|
|
|
// Returns a map that contains the name of the group and parameterGroupInfo with m_fields containing the information to be updated after matching the populations.
|
|
Map<String, ParametersGroupInfo> SessionManager::getUpdatedParameterGroupInfo(const ParametersGroupUpdate& parametersGroupUpdate)
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
Map<String, ParametersGroupInfo> parametersGroup;
|
|
const auto& cachePointer = getSessionManagerPopulations().getPopulationsCache();
|
|
if (!cachePointer.isValid())
|
|
{
|
|
US_LOG(LogLevel::Warning, LogCategory::Parameters, "Couldn't find population when receiving parameters partial update. No update is done.");
|
|
return parametersGroup;
|
|
}
|
|
const auto& cache = cachePointer->m_cache;
|
|
const auto populationsIterator = cache.find(m_facade.getManager().getWorkingSpaceId());
|
|
if (populationsIterator == cache.end())
|
|
{
|
|
return parametersGroup;
|
|
}
|
|
|
|
String finalPopulation = "noPopulation";
|
|
for (const auto& population : populationsIterator->second)
|
|
{
|
|
const String fullName = population.m_subject + "." + population.m_name;
|
|
|
|
auto populationIt = parametersGroupUpdate.populations.find(fullName);
|
|
if (populationIt != parametersGroupUpdate.populations.end())
|
|
{
|
|
finalPopulation = fullName;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const auto parametersGroupUpdateIterator = parametersGroupUpdate.populations.find(finalPopulation);
|
|
if (parametersGroupUpdateIterator != parametersGroupUpdate.populations.end())
|
|
{
|
|
ParametersGroupInfo group;
|
|
group.m_fields = parametersGroupUpdateIterator->second;
|
|
parametersGroup[parametersGroupUpdate.name] = group;
|
|
}
|
|
|
|
return parametersGroup;
|
|
}
|
|
|
|
bool SessionManager::updateApplicationGroupParameters(const ParametersGroupUpdate& parametersGroupUpdate)
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
const Map<String, ParametersGroupInfo>& groupUpdate = getUpdatedParameterGroupInfo(parametersGroupUpdate);
|
|
|
|
if (groupUpdate.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool isSuccess = m_parameters.updateApplicationParametersGroup(groupUpdate, m_applicationSwitches);
|
|
m_killSwitch = FeatureSwitchHelper::mergeFeatureSwitches(m_applicationSwitches, m_spaceSwitches);
|
|
|
|
return isSuccess;
|
|
}
|
|
|
|
bool SessionManager::updateSpaceGroupParameters(const ParametersGroupUpdate& parametersGroupUpdate)
|
|
{
|
|
US_PERF_TASK_FUNC_DETAIL();
|
|
const Map<String, ParametersGroupInfo>& groupUpdate = getUpdatedParameterGroupInfo(parametersGroupUpdate);
|
|
|
|
if (groupUpdate.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool isSuccess = m_parameters.updateSpaceParametersGroup(groupUpdate, m_spaceSwitches);
|
|
m_killSwitch = FeatureSwitchHelper::mergeFeatureSwitches(m_applicationSwitches, m_spaceSwitches);
|
|
updateParametersSettings();
|
|
|
|
return isSuccess;
|
|
}
|
|
|
|
const SessionManagerPopulations& SessionManager::getSessionManagerPopulations() const
|
|
{
|
|
return m_sessionManagerPopulations;
|
|
}
|
|
|
|
SessionManagerPopulations& SessionManager::getSessionManagerPopulationsRW()
|
|
{
|
|
return m_sessionManagerPopulations;
|
|
}
|
|
|
|
const SmartPtr<PlayerCredentials>& SessionManager::getStoredCredentials() const
|
|
{
|
|
return m_storedCredentials;
|
|
}
|
|
SmartPtr<PlayerCredentials>& SessionManager::getStoredCredentialsRW()
|
|
{
|
|
return m_storedCredentials;
|
|
}
|
|
|
|
void SessionManager::setStoredCredentials(const PlayerCredentials& credentials)
|
|
{
|
|
m_storedCredentials = US_NEW(PlayerCredentials, credentials);
|
|
#if defined(US_TARGET_SWITCH)
|
|
setStoredUserHandle(m_storedCredentials->getHandle());
|
|
#elif defined(US_TARGET_PS4) || defined(US_TARGET_PS5)
|
|
setStoredUserId(m_storedCredentials->getUserId());
|
|
#endif
|
|
}
|
|
|
|
bool SessionManager::isEventEndOfGame() const
|
|
{
|
|
return m_isEventEndOfGame;
|
|
}
|
|
|
|
void SessionManager::setEventEndOfGame()
|
|
{
|
|
// Note : Once this flag is set to true, it shouldn't go back to false
|
|
// The event system cannot be restarted to ensure the events are sent in the correct order to the servers.
|
|
m_isEventEndOfGame = true;
|
|
}
|
|
|
|
const WebSocketConnectionPtr& SessionManager::getConnection() const
|
|
{
|
|
return m_connection;
|
|
}
|
|
|
|
WebSocketConnectionPtr& SessionManager::getConnection()
|
|
{
|
|
return m_connection;
|
|
}
|
|
|
|
String SessionManager::getConnectionMetaData(void) const
|
|
{
|
|
return m_connectionMetaData;
|
|
}
|
|
|
|
void SessionManager::setConnectionMetaData(const String& connectionMetaData)
|
|
{
|
|
m_connectionMetaData = const_cast<String&>(connectionMetaData);
|
|
}
|
|
|
|
AsyncResult<String>& SessionManager::getPopUnsentEventsAsyncResultRW()
|
|
{
|
|
return m_popUnsentEventsResult;
|
|
}
|
|
|
|
#if defined(US_MODULE_CLUB)
|
|
const SessionManagerClub& SessionManager::getSessionManagerClub() const
|
|
{
|
|
return m_sessionManagerClub;
|
|
}
|
|
|
|
SessionManagerClub& SessionManager::getSessionManagerClubRW()
|
|
{
|
|
return m_sessionManagerClub;
|
|
}
|
|
#endif // defined(US_MODULE_CLUB)
|
|
|
|
#if defined(US_MODULE_STORE)
|
|
const SessionManagerStore& SessionManager::getSessionManagerStore() const
|
|
{
|
|
return m_sessionManagerStore;
|
|
}
|
|
|
|
SessionManagerStore& SessionManager::getSessionManagerStoreRW()
|
|
{
|
|
return m_sessionManagerStore;
|
|
}
|
|
#endif // defined(US_MODULE_STORE)
|
|
|
|
#if defined(US_TARGET_SWITCH)
|
|
void SessionManager::setStoredUserHandle(const nn::account::UserHandle& userHandle)
|
|
{
|
|
m_userHandle = userHandle;
|
|
m_isUserHandleSet = true;
|
|
}
|
|
|
|
const nn::account::UserHandle& SessionManager::getStoredUserHandle() const
|
|
{
|
|
return m_userHandle;
|
|
}
|
|
|
|
const bool SessionManager::isUserHandleSet() const
|
|
{
|
|
return m_isUserHandleSet;
|
|
}
|
|
#elif defined(US_TARGET_PS4) || defined(US_TARGET_PS5)
|
|
void SessionManager::setStoredUserId(const SceUserServiceUserId& userId)
|
|
{
|
|
m_userId = userId;
|
|
m_isUserIdSet = true;
|
|
}
|
|
|
|
const SceUserServiceUserId& SessionManager::getStoredUserId() const
|
|
{
|
|
return m_userId;
|
|
}
|
|
|
|
const bool SessionManager::isUserIdSet() const
|
|
{
|
|
return m_isUserIdSet;
|
|
}
|
|
#elif defined(US_TARGET_STADIA)
|
|
void SessionManager::setStoredPlayerId(const ggp::PlayerId& playerId)
|
|
{
|
|
m_playerId = playerId;
|
|
m_isPlayerIdSet = true;
|
|
}
|
|
|
|
const ggp::PlayerId& SessionManager::getStoredPlayerId() const
|
|
{
|
|
return m_playerId;
|
|
}
|
|
|
|
const bool SessionManager::isPlayerIdSet() const
|
|
{
|
|
return m_isPlayerIdSet;
|
|
}
|
|
#endif
|
|
|
|
void SessionManager::setConcurrentConnectRestPeriodInProgress(bool enabled)
|
|
{
|
|
m_concurrentConnectRestPeriodInProgress = enabled;
|
|
}
|
|
|
|
const bool SessionManager::isConcurrentConnectRestPeriodInProgress()
|
|
{
|
|
return m_concurrentConnectRestPeriodInProgress;
|
|
}
|
|
|
|
#elif defined(US_SDK_SERVER)
|
|
void SessionManager::setUbiCertificateKeyPublic(const String& ubiCertificateKeyPublic)
|
|
{
|
|
m_certificateKeyPublic = ubiCertificateKeyPublic;
|
|
m_isCertificatePublicKeySet = true;
|
|
}
|
|
|
|
const String SessionManager::getUbiCertificateKeyPublic() const
|
|
{
|
|
return m_certificateKeyPublic;
|
|
}
|
|
|
|
void SessionManager::setUbiCertificateKeyPrivateObfuscated(const Vector<uint8>& ubiCertificateKeyPrivateObfuscated)
|
|
{
|
|
m_certificateKeyPrivateObfuscated = ubiCertificateKeyPrivateObfuscated;
|
|
}
|
|
|
|
const Vector<uint8>& SessionManager::getUbiCertificateKeyPrivateObfuscated() const
|
|
{
|
|
return m_certificateKeyPrivateObfuscated;
|
|
}
|
|
|
|
void SessionManager::setServerCreateSessionOverrideSpaceId(const SpaceId& spaceId)
|
|
{
|
|
m_serverCreateSessionOverrideSpaceId = spaceId;
|
|
}
|
|
|
|
const SpaceId& SessionManager::getServerCreateSessionOverrideSpaceId() const
|
|
{
|
|
return m_serverCreateSessionOverrideSpaceId;
|
|
}
|
|
|
|
const bool SessionManager::isCertificatePublicSet() const
|
|
{
|
|
return m_isCertificatePublicKeySet;
|
|
}
|
|
|
|
#endif
|
|
};
|