onlineservices.c

Go to the documentation of this file.

class OnlineServices
{
 static ref ScriptInvoker m_FriendsAsyncInvoker = new ScriptInvoker();
 static ref ScriptInvoker m_PermissionsAsyncInvoker = new ScriptInvoker();
 static ref ScriptInvoker m_ServersAsyncInvoker = new ScriptInvoker();
 static ref ScriptInvoker m_ServerAsyncInvoker = new ScriptInvoker();
 static ref ScriptInvoker m_MuteUpdateAsyncInvoker = new ScriptInvoker(); // DEPRECATED
 static ref ScriptInvoker m_ServerModLoadAsyncInvoker = new ScriptInvoker();
 
 static ref BiosClientServices m_ClientServices;
 static ref TrialService m_TrialService;
 
 protected static string m_InviteServerIP;
 protected static int m_InviteServerPort;
 protected static string m_CurrentServerIP;
 protected static int m_CurrentServerPort;
 protected static ref GetServersResultRow m_CurrentServerInfo;
 
 
 protected static ref map<string, ref BiosFriendInfo> m_FriendsList;
 protected static ref map<string, bool> m_MuteList;
 protected static ref map<string, ref BiosPrivacyPermissionResultArray> m_PermissionsList;
 
 protected static bool m_FirstFriendsLoad = true;
 protected static bool m_MultiplayState = false;
 protected static ref array<string> m_PendingInvites;
 
 protected static ref BiosUser m_BiosUser;
 
 static void Init()
 {
 #ifdef PLATFORM_CONSOLE
 #ifndef PLATFORM_WINDOWS // if app is not on Windows with -XBOX parameter
 if ( !m_TrialService )
 m_TrialService = new TrialService;
 if ( !m_FriendsList )
 m_FriendsList = new map<string, ref BiosFriendInfo>;
 if ( !m_MuteList )
 m_MuteList = new map<string, bool>;
 if ( !m_PermissionsList )
 m_PermissionsList = new map<string, ref BiosPrivacyPermissionResultArray>;
 
 m_FriendsList.Clear();
 m_PermissionsList.Clear();
 m_MuteList.Clear();
 #endif
 #endif
 
 GetClientServices();
 }
 
 static bool IsInitialized()
 {
 return ( m_ClientServices != null );
 }
 
 static void GetClientServices()
 {
 BiosUserManager user_manager = GetGame().GetUserManager();
 if ( user_manager )
 {
 BiosUser selected_user = user_manager.GetSelectedUser();
 if ( selected_user )
 {
 m_ClientServices = selected_user.GetClientServices();
 }
 #ifdef PLATFORM_WINDOWS
 array<ref BiosUser> user_list = new array<ref BiosUser>;
 user_manager.GetUserList( user_list );
 if ( user_list.Count() > 0 )
 {
 m_ClientServices = user_list.Get( 0 ).GetClientServices();
 }
 #endif
 }
 else
 {
 Error( "BiosClientServices Error: Usermanager does not exist." );
 }
 }
 
 static bool ErrorCaught( EBiosError error )
 {
 switch ( error )
 {
 case EBiosError.OK:
 {
 return false;
 }
 }
 
 DebugPrint.LogErrorAndTrace( string.Format("BiosClientServices Error: %1", ErrorModuleHandler.GetClientMessage(ErrorCategory.BIOSError, error)) );
 return true;
 }
 
 static void LoadServers( notnull GetServersInput inputValues )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetLobbyService().GetServers( inputValues );
 }
 else
 {
 DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
 }
 }
 
 static void GetFavoriteServers(TStringArray favServers)
 {
 m_ClientServices.GetLobbyService().GetFavoriteServers(favServers);
 }
 
 static void GetCachedFavServerInfo(array<ref CachedServerInfo> favServersInfoCache)
 {
 m_ClientServices.GetLobbyService().GetCachedFavoriteServerInfo(favServersInfoCache);
 }
 
 static void SetServerFavorited(string ipAddress, int port, int steamQueryPort, bool is_favorited )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 if ( is_favorited )
 {
 m_ClientServices.GetLobbyService().AddServerFavorite( ipAddress, port, steamQueryPort );
 }
 else
 {
 m_ClientServices.GetLobbyService().RemoveServerFavorite( ipAddress, port, steamQueryPort );
 }
 }
 else
 {
 DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
 }
 }
 
 static void GetCurrentServerInfo( string ip, int port )
 {
 GetClientServices();
 
 m_CurrentServerIP = ip;
 m_CurrentServerPort = port;
 
 GetServersInput inputValues = new GetServersInput;
 
 inputValues.SetHostIp( ip );
 inputValues.SetHostPort( port );
 inputValues.m_Page = 0;
 inputValues.m_RowsPerPage = 10;
 inputValues.m_Platform = 1;
 
 #ifdef PLATFORM_XBOX
 inputValues.m_Platform = 2;
 #endif
 #ifdef PLATFORM_PS4
 inputValues.m_Platform = 3;
 #endif
 
 if ( m_ClientServices )
 {
 m_ClientServices.GetLobbyService().GetServers( inputValues );
 }
 }
 
 static GetServersResultRow GetCurrentServerInfo()
 {
 if (m_CurrentServerInfo)
 return m_CurrentServerInfo;
 else
 return g_Game.GetHostData();
 }
 
 static void ClearCurrentServerInfo()
 {
 m_CurrentServerInfo = null;
 m_CurrentServerIP = "";
 m_CurrentServerPort = 0;
 }
 
 static void SetInviteServerInfo( string ip, int port )
 {
 m_InviteServerIP = ip;
 m_InviteServerPort = port;
 }
 
 static void GetInviteServerInfo( out string ip, out int port )
 {
 ip = m_InviteServerIP;
 port = m_InviteServerPort;
 }
 
 static void OnLoadServersAsync( GetServersResult result_list, EBiosError error, string response )
 {
 if ( !ErrorCaught( error ) )
 {
 if ( m_CurrentServerIP != "" && m_CurrentServerPort > 0 )
 {
 foreach ( GetServersResultRow result : result_list.m_Results )
 {
 if ( result.m_HostIp == m_CurrentServerIP && result.m_HostPort == m_CurrentServerPort )
 {
 m_CurrentServerInfo = result;
 m_CurrentServerIP = "";
 m_CurrentServerPort = 0;
 }
 }
 }
 
 // todo: remove
 //foreach( GetServersResultRow res : result_list.m_Results )
 //{
 // Print("OnLoadServersAsync: result id: " + res.m_Id + "modded: " + res.m_Modded);
 //}
 
 // just for example execute the retrieving of extended info for the first server entry in the list
 //if (result_list.m_Results.Count() > 0)
 //{
 //GetServersResultRow re = result_list.m_Results[0];
 //EBiosError er = m_ClientServices.GetLobbyService().GetServerModList(re.m_Id);
 //Print("OnLoadServersAsync GetServerModList returns:" + er);
 //}
 
 m_ServersAsyncInvoker.Invoke( result_list, error, response );
 }
 else
 {
 m_ServersAsyncInvoker.Invoke( null, error, "" );
 }
 }
 
 
 static void LoadFriends()
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetSocialService().GetFriendsAsync();
 }
 else
 {
 DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
 }
 }
 
 static void ShowUserProfile( string uid )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetSocialService().ShowUserProfileAsync( uid );
 }
 else
 {
 DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
 }
 }
 
 static void OnUserProfileAsync(EBiosError error)
 {
 ErrorCaught( error );
 }
 
 static void OnFriendsAsync( BiosFriendInfoArray friend_list, EBiosError error )
 {
 if ( !ErrorCaught( error ) )
 {
 m_FriendsAsyncInvoker.Invoke( friend_list );
 
 array<string> friends_simple = new array<string>;
 for ( int i = 0; i < friend_list.Count(); ++i )
 {
 string uid = friend_list[i].m_Uid;
 BiosFriendInfo storedBfi = m_FriendsList[uid];
 BiosFriendInfo newBfi = friend_list[i];
 
 if (storedBfi)
 {
 if ( !BiosFriendInfo.Compare( storedBfi, newBfi ) )
 {
 friends_simple.Insert( newBfi.m_Uid );
 }
 m_FriendsList.Set( uid, newBfi );
 }
 else
 {
 m_FriendsList.Insert( uid, newBfi );
 friends_simple.Insert( newBfi.m_Uid );
 }
 }
 
 if ( !m_FirstFriendsLoad )
 {
 if ( ClientData.m_LastNewPlayers && ClientData.m_LastNewPlayers.m_PlayerList.Count() > 0 )
 {
 foreach ( SyncPlayer player : ClientData.m_LastNewPlayers.m_PlayerList )
 {
 if ( m_FriendsList.Contains( player.m_UID ) )
 {
 NotificationSystem.AddNotification( NotificationType.FRIEND_CONNECTED, NotificationSystem.DEFAULT_TIME_DISPLAYED, player.m_PlayerName + " " + "#ps4_invite_has_joined_your_session" );
 }
 }
 ClientData.m_LastNewPlayers.m_PlayerList.Clear();
 }
 }
 m_FirstFriendsLoad = false;
 }
 }
 
 static void LoadPermissions( array<string> player_list )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 array<EBiosPrivacyPermission> perms = new array<EBiosPrivacyPermission>;
 perms.Insert( EBiosPrivacyPermission.COMMUNICATE_VOICE );
 
 ErrorCaught( m_ClientServices.GetPrivacyService().GetPermissionsAsync( player_list, perms ) );
 }
 else
 {
 DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
 }
 }
 
 static void OnPermissionsAsync( BiosPrivacyUidResultArray result_list, EBiosError error )
 {
 if ( !ErrorCaught( error ) )
 {
 BiosPrivacyUidResultArray new_list = new BiosPrivacyUidResultArray;
 
 for ( int i = 0; i < result_list.Count(); i++ )
 {
 BiosPrivacyUidResult result = result_list.Get( i );
 string uid = result.m_Uid;
 BiosPrivacyPermissionResultArray result_array = m_PermissionsList.Get( uid );
 BiosPrivacyPermissionResultArray result_array2 = result.m_Results;
 if ( result_array && result_array2 )
 {
 if ( !BiosPrivacyPermissionResult.Compare( result_array.Get( 0 ), result_array2.Get( 0 ) ) )
 {
 new_list.Insert( result );
 m_PermissionsList.Set( uid, result_array2 );
 }
 }
 else
 {
 m_PermissionsList.Insert( uid, result_array2 );
 new_list.Insert( result );
 }
 }
 m_PermissionsAsyncInvoker.Invoke( new_list );
 }
 }
 
 static bool IsPlayerMuted( string id )
 {
 if ( m_MuteList.Contains( id ) )
 {
 return m_MuteList.Get( id );
 }
 return false;
 }
 
 static bool MutePlayer( string id, bool mute )
 {
 if ( m_MuteList.Contains( id ) )
 {
 m_MuteList.Set( id, mute );
 }
 else
 {
 m_MuteList.Insert( id, mute );
 }
 
 // notify server
 ScriptInputUserData ctx = new ScriptInputUserData();
 ctx.Write( INPUT_UDT_USER_MUTE_XBOX );
 ctx.Write( id );
 ctx.Write( mute );
 ctx.Send();
 
 return true;
 }
 
 static map<string, bool> GetMuteList()
 {
 return m_MuteList;
 }
 
 static void ShowInviteScreen()
 {
 #ifdef PLATFORM_CONSOLE
 GetClientServices();
 if ( m_ClientServices )
 {
 string addr;
 int port;
 if ( GetGame().GetHostAddress( addr, port ) )
 {
 ErrorCaught( m_ClientServices.GetSessionService().ShowInviteToGameplaySessionAsync( addr, port ) );
 }
 }
 else
 {
 DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
 }
 #endif
 }
 
 static void LoadMPPrivilege()
 {
 #ifdef PLATFORM_CONSOLE
 GetClientServices();
 if ( m_ClientServices )
 {
 ErrorCaught( m_ClientServices.GetPrivacyService().GetPrivilegeAsync( EBiosPrivacyPrivilege.MULTIPLAYER_GAMEPLAY, true ) );
 }
 else
 {
 DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
 }
 #else
 OnLoadMPPrivilege( EBiosError.OK );
 #endif
 }
 
 static void LoadVoicePrivilege()
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 ErrorCaught( m_ClientServices.GetPrivacyService().GetPrivilegeAsync( EBiosPrivacyPrivilege.COMMUNICATE_VOICE, true ) );
 }
 else
 {
 DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
 }
 }
 
 static void OnLoadMPPrivilege( EBiosError err )
 {
 if ( !ErrorCaught( err ) )
 {
 g_Game.TryConnect();
 }
 else
 {
 if ( g_Game.GetGameState() != DayZGameState.MAIN_MENU )
 {
 g_Game.MainMenuLaunch();
 }
 else
 {
 g_Game.SetLoadState( DayZLoadState.MAIN_MENU_START );
 g_Game.GamepadCheck();
 }
 }
 }
 
 static void OnLoadVoicePrivilege( EBiosError err )
 {
 if ( g_Game.GetGameState() == DayZGameState.IN_GAME )
 {
 #ifdef PLATFORM_PS4
 GetGame().GetWorld().DisableReceiveVoN( ErrorCaught( err ) );
 #endif
 GetGame().GetWorld().DisableTransmitVoN( ErrorCaught( err ) );
 }
 }
 
 static void SetSessionHandle( string handle )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetSessionService().m_CurrentHandle = handle;
 }
 }
 
 static string GetSessionHandle()
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 return m_ClientServices.GetSessionService().m_CurrentHandle;
 }
 return "";
 }
 
 static void GetSession()
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetSessionService().TryGetSession( GetSessionHandle() );
 }
 }
 
 static BiosUser GetBiosUser()
 {
 return m_BiosUser;
 }
 
 static void SetBiosUser(BiosUser user)
 {
 m_BiosUser = user;
 }
 
 
 static bool GetMultiplayState()
 {
 return m_MultiplayState;
 }
 
 static void SetMultiplayState( bool state )
 {
 m_MultiplayState = state;
 bool is_multiplay;
 if ( ClientData.GetSimplePlayerList() )
 is_multiplay = state && ( ClientData.GetSimplePlayerList().Count() > 1 );
 
 if ( m_ClientServices )
 m_ClientServices.GetSessionService().SetMultiplayState(is_multiplay);
 }
 
 static void EnterGameplaySession()
 {
 string addr;
 int port;
 if ( GetGame().GetHostAddress( addr, port ) )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetSessionService().EnterGameplaySessionAsync( addr, port );
 SetMultiplayState(true);
 }
 }
 }
 
 static void LeaveGameplaySession()
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 GetServersResultRow currentServerInfo = GetCurrentServerInfo();
 
 if ( currentServerInfo )
 m_ClientServices.GetSessionService().LeaveGameplaySessionAsync(currentServerInfo.m_HostIp, currentServerInfo.m_HostPort);
 else if ( m_CurrentServerIP != "" )
 m_ClientServices.GetSessionService().LeaveGameplaySessionAsync(m_CurrentServerIP, m_CurrentServerPort);
 
 SetMultiplayState(false);
 m_FirstFriendsLoad = true;
 
 if ( m_FriendsList )
 m_FriendsList.Clear();
 }
 }
 
 static void SetGameplayActivity()
 {
 string addr;
 int port;
 if ( GetGame().GetHostAddress( addr, port ) )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetSessionService().SetGameplayActivityAsync( addr, port );
 }
 }
 }
 
 static void SetPendingInviteList( array<string> invitees )
 {
 string addr;
 int port;
 if ( GetGame().GetHostAddress( addr, port ) )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_PendingInvites = invitees;
 m_ClientServices.GetSessionService().InviteToGameplaySessionAsync( addr, port, GetPendingInviteList() );
 }
 }
 else
 {
 m_PendingInvites = invitees;
 }
 }
 
 static array<string> GetPendingInviteList()
 {
 array<string> already_on_server = ClientData.GetSimplePlayerList();
 if ( already_on_server && m_PendingInvites )
 {
 array<string> new_to_server = new array<string>;
 foreach ( string invitee : m_PendingInvites )
 {
 if ( already_on_server.Find( invitee ) == -1 )
 {
 new_to_server.Insert( invitee );
 }
 }
 return new_to_server;
 }
 else
 {
 return m_PendingInvites;
 }
 }
 
 static void ClearPendingInviteList( array<string> invitees )
 {
 delete m_PendingInvites;
 }
 
 static int m_AutoConnectTries = 0;
 static void AutoConnectToEmptyServer()
 {
 GetClientServices();
 if ( m_ClientServices && m_AutoConnectTries == 0 )
 {
 m_AutoConnectTries = 1;
 GetFirstServerWithEmptySlotInput input = new GetFirstServerWithEmptySlotInput;
 input.SetOfficial( true );
 m_ClientServices.GetLobbyService().GetFirstServerWithEmptySlot( input );
 }
 }
 
 static GetServersResultRow GetRandomFreeResult( GetFirstServerWithEmptySlotResult results )
 {
 GetServersResultRow result;
 array<ref GetServersResultRow> results_free = new array<ref GetServersResultRow>;
 
 if ( results && results.m_Result && results.m_Result.m_Results && results.m_Result.m_Results.Count() > 0 )
 {
 foreach ( GetServersResultRow result_temp : results.m_Result.m_Results )
 {
 if ( result_temp.m_FreeSlots > 0 )
 {
 results_free.Insert( result_temp );
 }
 }
 }
 
 return results_free.GetRandomElement();
 }
 
 static void OnAutoConnectToEmptyServer( GetFirstServerWithEmptySlotResult result_list, EBiosError error )
 {
 if ( !ErrorCaught( error ) )
 {
 GetServersResultRow result = GetRandomFreeResult( result_list );
 if ( result )
 {
 g_Game.ConnectFromServerBrowser( result.m_HostIp, result.m_HostPort );
 m_AutoConnectTries = 0;
 return;
 }
 else
 {
 GetGame().GetUIManager().ShowDialog( "#str_xbox_authentification_fail_title", "#str_xbox_authentification_fail", 232, DBT_OK, DBB_NONE, DMT_INFO, GetGame().GetUIManager().GetMenu() );
 }
 }
 
 if ( m_AutoConnectTries < 3 )
 {
 m_AutoConnectTries++;
 GetFirstServerWithEmptySlotInput input = new GetFirstServerWithEmptySlotInput;
 input.SetOfficial( true );
 m_ClientServices.GetLobbyService().GetFirstServerWithEmptySlot( input );
 }
 else
 {
 GetGame().GetUIManager().ShowDialog( "#str_xbox_authentification_fail_title", "#xbox_authentification_fail", 232, DBT_OK, DBB_NONE, DMT_INFO, GetGame().GetUIManager().GetMenu() );
 }
 }
 
 static void GetServerModList( string server_id )
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetLobbyService().GetServerModList( server_id );
 }
 }
 
 static void OnGetServerModList( GetServerModListResult result_list, EBiosError error )
 {
 if ( !ErrorCaught( error ) )
 {
 m_ServerModLoadAsyncInvoker.Invoke( result_list );
 }
 }
 
 static bool IsGameTrial( bool sim )
 {
 #ifdef PLATFORM_XBOX
 #ifndef PLATFORM_WINDOWS
 if ( m_TrialService )
 return m_TrialService.IsGameTrial( sim );
 #endif
 #endif
 return false;
 }
 
 static bool IsGameActive( bool sim )
 {
 #ifdef PLATFORM_XBOX
 #ifndef PLATFORM_WINDOWS
 if ( m_TrialService )
 return m_TrialService.IsGameActive( sim );
 #endif
 #endif
 return false;
 }
 
 static bool CheckUpdate()
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 EBiosError error = m_ClientServices.GetPackageService().CheckUpdateAsync();
 
 if ( !error )
 {
 return true;
 }
 }
 
 return false;
 }
 
 static void PromptUpdate()
 {
 GetClientServices();
 if ( m_ClientServices )
 {
 m_ClientServices.GetPackageService().PromptUpdateAsync();
 }
 }
}