Dayz Explorer  1.24.157551 (v105080)
Dayz Code Explorer by Zeroy
onlineservices.c
Go to the documentation of this file.
2 {
3  static ref ScriptInvoker m_FriendsAsyncInvoker = new ScriptInvoker();
4  static ref ScriptInvoker m_PermissionsAsyncInvoker = new ScriptInvoker();
5  static ref ScriptInvoker m_ServersAsyncInvoker = new ScriptInvoker();
6  static ref ScriptInvoker m_ServerAsyncInvoker = new ScriptInvoker();
7  static ref ScriptInvoker m_MuteUpdateAsyncInvoker = new ScriptInvoker(); // DEPRECATED
8  static ref ScriptInvoker m_ServerModLoadAsyncInvoker = new ScriptInvoker();
9 
10  static ref BiosClientServices m_ClientServices;
11  static ref TrialService m_TrialService;
12 
13  protected static string m_InviteServerIP;
14  protected static int m_InviteServerPort;
15  protected static string m_CurrentServerIP;
16  protected static int m_CurrentServerPort;
17  protected static ref GetServersResultRow m_CurrentServerInfo;
18 
19 
20  protected static ref map<string, ref BiosFriendInfo> m_FriendsList;
21  protected static ref map<string, bool> m_MuteList;
22  protected static ref map<string, ref BiosPrivacyPermissionResultArray> m_PermissionsList;
23 
24  protected static bool m_FirstFriendsLoad = true;
25  protected static bool m_MultiplayState = false;
26  protected static ref array<string> m_PendingInvites;
27 
28  protected static ref BiosUser m_BiosUser;
29 
30  static void Init()
31  {
32  #ifdef PLATFORM_CONSOLE
33  #ifndef PLATFORM_WINDOWS // if app is not on Windows with -XBOX parameter
34  if ( !m_TrialService )
35  m_TrialService = new TrialService;
36  if ( !m_FriendsList )
37  m_FriendsList = new map<string, ref BiosFriendInfo>;
38  if ( !m_MuteList )
39  m_MuteList = new map<string, bool>;
40  if ( !m_PermissionsList )
42 
43  m_FriendsList.Clear();
44  m_PermissionsList.Clear();
45  m_MuteList.Clear();
46  #endif
47  #endif
48 
49  GetClientServices();
50  }
51 
52  static bool IsInitialized()
53  {
54  return ( m_ClientServices != null );
55  }
56 
57  static void GetClientServices()
58  {
59  BiosUserManager user_manager = GetGame().GetUserManager();
60  if ( user_manager )
61  {
62  BiosUser selected_user = user_manager.GetSelectedUser();
63  if ( selected_user )
64  {
65  m_ClientServices = selected_user.GetClientServices();
66  }
67  #ifdef PLATFORM_WINDOWS
69  user_manager.GetUserList( user_list );
70  if ( user_list.Count() > 0 )
71  {
72  m_ClientServices = user_list.Get( 0 ).GetClientServices();
73  }
74  #endif
75  }
76  else
77  {
78  Error( "BiosClientServices Error: Usermanager does not exist." );
79  }
80  }
81 
82  static bool ErrorCaught( EBiosError error )
83  {
84  switch ( error )
85  {
86  case EBiosError.OK:
87  {
88  return false;
89  }
90  }
91 
92  DebugPrint.LogErrorAndTrace( string.Format("BiosClientServices Error: %1", ErrorModuleHandler.GetClientMessage(ErrorCategory.BIOSError, error)) );
93  return true;
94  }
95 
96  static void LoadServers( notnull GetServersInput inputValues )
97  {
98  GetClientServices();
99  if ( m_ClientServices )
100  {
101  m_ClientServices.GetLobbyService().GetServers( inputValues );
102  }
103  else
104  {
105  DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
106  }
107  }
108 
109  static void GetFavoriteServers(TStringArray favServers)
110  {
111  m_ClientServices.GetLobbyService().GetFavoriteServers(favServers);
112  }
113 
114  static void GetCachedFavServerInfo(array<ref CachedServerInfo> favServersInfoCache)
115  {
116  m_ClientServices.GetLobbyService().GetCachedFavoriteServerInfo(favServersInfoCache);
117  }
118 
119  static void SetServerFavorited(string ipAddress, int port, int steamQueryPort, bool is_favorited )
120  {
121  GetClientServices();
122  if ( m_ClientServices )
123  {
124  if ( is_favorited )
125  {
126  m_ClientServices.GetLobbyService().AddServerFavorite( ipAddress, port, steamQueryPort );
127  }
128  else
129  {
130  m_ClientServices.GetLobbyService().RemoveServerFavorite( ipAddress, port, steamQueryPort );
131  }
132  }
133  else
134  {
135  DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
136  }
137  }
138 
139  static void GetCurrentServerInfo( string ip, int port )
140  {
141  GetClientServices();
142 
143  m_CurrentServerIP = ip;
144  m_CurrentServerPort = port;
145 
146  GetServersInput inputValues = new GetServersInput;
147 
148  inputValues.SetHostIp( ip );
149  inputValues.SetHostPort( port );
150  inputValues.m_Page = 0;
151  inputValues.m_RowsPerPage = 10;
152  inputValues.m_Platform = 1;
153 
154  #ifdef PLATFORM_XBOX
155  inputValues.m_Platform = 2;
156  #endif
157  #ifdef PLATFORM_PS4
158  inputValues.m_Platform = 3;
159  #endif
160 
161  if ( m_ClientServices )
162  {
163  m_ClientServices.GetLobbyService().GetServers( inputValues );
164  }
165  }
166 
167  static GetServersResultRow GetCurrentServerInfo()
168  {
169  if (m_CurrentServerInfo)
170  return m_CurrentServerInfo;
171  else
172  return g_Game.GetHostData();
173  }
174 
175  static void ClearCurrentServerInfo()
176  {
177  m_CurrentServerInfo = null;
178  m_CurrentServerIP = "";
179  m_CurrentServerPort = 0;
180  }
181 
182  static void SetInviteServerInfo( string ip, int port )
183  {
184  m_InviteServerIP = ip;
185  m_InviteServerPort = port;
186  }
187 
188  static void GetInviteServerInfo( out string ip, out int port )
189  {
190  ip = m_InviteServerIP;
191  port = m_InviteServerPort;
192  }
193 
194  static void OnLoadServersAsync( GetServersResult result_list, EBiosError error, string response )
195  {
196  if ( !ErrorCaught( error ) )
197  {
198  if ( m_CurrentServerIP != "" && m_CurrentServerPort > 0 )
199  {
200  foreach ( GetServersResultRow result : result_list.m_Results )
201  {
202  if ( result.m_HostIp == m_CurrentServerIP && result.m_HostPort == m_CurrentServerPort )
203  {
204  m_CurrentServerInfo = result;
205  m_CurrentServerIP = "";
206  m_CurrentServerPort = 0;
207  }
208  }
209  }
210 
211  // todo: remove
212  //foreach( GetServersResultRow res : result_list.m_Results )
213  //{
214  // Print("OnLoadServersAsync: result id: " + res.m_Id + "modded: " + res.m_Modded);
215  //}
216 
217  // just for example execute the retrieving of extended info for the first server entry in the list
218  //if (result_list.m_Results.Count() > 0)
219  //{
220  //GetServersResultRow re = result_list.m_Results[0];
221  //EBiosError er = m_ClientServices.GetLobbyService().GetServerModList(re.m_Id);
222  //Print("OnLoadServersAsync GetServerModList returns:" + er);
223  //}
224 
225  m_ServersAsyncInvoker.Invoke( result_list, error, response );
226  }
227  else
228  {
229  m_ServersAsyncInvoker.Invoke( null, error, "" );
230  }
231  }
232 
233 
234  static void LoadFriends()
235  {
236  GetClientServices();
237  if ( m_ClientServices )
238  {
239  m_ClientServices.GetSocialService().GetFriendsAsync();
240  }
241  else
242  {
243  DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
244  }
245  }
246 
247  static void ShowUserProfile( string uid )
248  {
249  GetClientServices();
250  if ( m_ClientServices )
251  {
252  m_ClientServices.GetSocialService().ShowUserProfileAsync( uid );
253  }
254  else
255  {
256  DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
257  }
258  }
259 
260  static void OnUserProfileAsync(EBiosError error)
261  {
262  ErrorCaught( error );
263  }
264 
265  static void OnFriendsAsync( BiosFriendInfoArray friend_list, EBiosError error )
266  {
267  if ( !ErrorCaught( error ) )
268  {
269  m_FriendsAsyncInvoker.Invoke( friend_list );
270 
271  array<string> friends_simple = new array<string>;
272  for ( int i = 0; i < friend_list.Count(); ++i )
273  {
274  string uid = friend_list[i].m_Uid;
275  BiosFriendInfo storedBfi = m_FriendsList[uid];
276  BiosFriendInfo newBfi = friend_list[i];
277 
278  if (storedBfi)
279  {
280  if ( !BiosFriendInfo.Compare( storedBfi, newBfi ) )
281  {
282  friends_simple.Insert( newBfi.m_Uid );
283  }
284  m_FriendsList.Set( uid, newBfi );
285  }
286  else
287  {
288  m_FriendsList.Insert( uid, newBfi );
289  friends_simple.Insert( newBfi.m_Uid );
290  }
291  }
292 
293  if ( !m_FirstFriendsLoad )
294  {
295  if ( ClientData.m_LastNewPlayers && ClientData.m_LastNewPlayers.m_PlayerList.Count() > 0 )
296  {
297  foreach ( SyncPlayer player : ClientData.m_LastNewPlayers.m_PlayerList )
298  {
299  if ( m_FriendsList.Contains( player.m_UID ) )
300  {
301  NotificationSystem.AddNotification( NotificationType.FRIEND_CONNECTED, NotificationSystem.DEFAULT_TIME_DISPLAYED, player.m_PlayerName + " " + "#ps4_invite_has_joined_your_session" );
302  }
303  }
304  ClientData.m_LastNewPlayers.m_PlayerList.Clear();
305  }
306  }
307  m_FirstFriendsLoad = false;
308  }
309  }
310 
311  static void LoadPermissions( array<string> player_list )
312  {
313  GetClientServices();
314  if ( m_ClientServices )
315  {
317  perms.Insert( EBiosPrivacyPermission.COMMUNICATE_VOICE );
318 
319  ErrorCaught( m_ClientServices.GetPrivacyService().GetPermissionsAsync( player_list, perms ) );
320  }
321  else
322  {
323  DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
324  }
325  }
326 
327  static void OnPermissionsAsync( BiosPrivacyUidResultArray result_list, EBiosError error )
328  {
329  if ( !ErrorCaught( error ) )
330  {
332 
333  for ( int i = 0; i < result_list.Count(); i++ )
334  {
335  BiosPrivacyUidResult result = result_list.Get( i );
336  string uid = result.m_Uid;
337  BiosPrivacyPermissionResultArray result_array = m_PermissionsList.Get( uid );
338  BiosPrivacyPermissionResultArray result_array2 = result.m_Results;
339  if ( result_array && result_array2 )
340  {
341  if ( !BiosPrivacyPermissionResult.Compare( result_array.Get( 0 ), result_array2.Get( 0 ) ) )
342  {
343  new_list.Insert( result );
344  m_PermissionsList.Set( uid, result_array2 );
345  }
346  }
347  else
348  {
349  m_PermissionsList.Insert( uid, result_array2 );
350  new_list.Insert( result );
351  }
352  }
353  m_PermissionsAsyncInvoker.Invoke( new_list );
354  }
355  }
356 
357  static bool IsPlayerMuted( string id )
358  {
359  if ( m_MuteList.Contains( id ) )
360  {
361  return m_MuteList.Get( id );
362  }
363  return false;
364  }
365 
366  static bool MutePlayer( string id, bool mute )
367  {
368  if ( m_MuteList.Contains( id ) )
369  {
370  m_MuteList.Set( id, mute );
371  }
372  else
373  {
374  m_MuteList.Insert( id, mute );
375  }
376 
377  // notify server
379  ctx.Write( INPUT_UDT_USER_MUTE_XBOX );
380  ctx.Write( id );
381  ctx.Write( mute );
382  ctx.Send();
383 
384  return true;
385  }
386 
387  static map<string, bool> GetMuteList()
388  {
389  return m_MuteList;
390  }
391 
392  static void ShowInviteScreen()
393  {
394  #ifdef PLATFORM_CONSOLE
395  GetClientServices();
396  if ( m_ClientServices )
397  {
398  string addr;
399  int port;
400  if ( GetGame().GetHostAddress( addr, port ) )
401  {
402  ErrorCaught( m_ClientServices.GetSessionService().ShowInviteToGameplaySessionAsync( addr, port ) );
403  }
404  }
405  else
406  {
407  DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
408  }
409  #endif
410  }
411 
412  static void LoadMPPrivilege()
413  {
414  #ifdef PLATFORM_CONSOLE
415  GetClientServices();
416  if ( m_ClientServices )
417  {
418  ErrorCaught( m_ClientServices.GetPrivacyService().GetPrivilegeAsync( EBiosPrivacyPrivilege.MULTIPLAYER_GAMEPLAY, true ) );
419  }
420  else
421  {
422  DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
423  }
424  #else
425  OnLoadMPPrivilege( EBiosError.OK );
426  #endif
427  }
428 
429  static void LoadVoicePrivilege()
430  {
431  GetClientServices();
432  if ( m_ClientServices )
433  {
434  ErrorCaught( m_ClientServices.GetPrivacyService().GetPrivilegeAsync( EBiosPrivacyPrivilege.COMMUNICATE_VOICE, true ) );
435  }
436  else
437  {
438  DebugPrint.LogErrorAndTrace( "BiosClientServices Error: Service reference does not exist." );
439  }
440  }
441 
442  static void OnLoadMPPrivilege( EBiosError err )
443  {
444  if ( !ErrorCaught( err ) )
445  {
446  g_Game.TryConnect();
447  }
448  else
449  {
450  if ( g_Game.GetGameState() != DayZGameState.MAIN_MENU )
451  {
452  g_Game.MainMenuLaunch();
453  }
454  else
455  {
456  g_Game.SetLoadState( DayZLoadState.MAIN_MENU_START );
457  g_Game.GamepadCheck();
458  }
459  }
460  }
461 
462  static void OnLoadVoicePrivilege( EBiosError err )
463  {
464  if ( g_Game.GetGameState() == DayZGameState.IN_GAME )
465  {
466  #ifdef PLATFORM_PS4
467  GetGame().GetWorld().DisableReceiveVoN( ErrorCaught( err ) );
468  #endif
469  GetGame().GetWorld().DisableTransmitVoN( ErrorCaught( err ) );
470  }
471  }
472 
473  static void SetSessionHandle( string handle )
474  {
475  GetClientServices();
476  if ( m_ClientServices )
477  {
478  m_ClientServices.GetSessionService().m_CurrentHandle = handle;
479  }
480  }
481 
482  static string GetSessionHandle()
483  {
484  GetClientServices();
485  if ( m_ClientServices )
486  {
487  return m_ClientServices.GetSessionService().m_CurrentHandle;
488  }
489  return "";
490  }
491 
492  static void GetSession()
493  {
494  GetClientServices();
495  if ( m_ClientServices )
496  {
497  m_ClientServices.GetSessionService().TryGetSession( GetSessionHandle() );
498  }
499  }
500 
501  static BiosUser GetBiosUser()
502  {
503  return m_BiosUser;
504  }
505 
506  static void SetBiosUser(BiosUser user)
507  {
508  m_BiosUser = user;
509  }
510 
511 
512  static bool GetMultiplayState()
513  {
514  return m_MultiplayState;
515  }
516 
517  static void SetMultiplayState( bool state )
518  {
519  m_MultiplayState = state;
520  bool is_multiplay;
521  if ( ClientData.GetSimplePlayerList() )
522  is_multiplay = state && ( ClientData.GetSimplePlayerList().Count() > 1 );
523 
524  if ( m_ClientServices )
525  m_ClientServices.GetSessionService().SetMultiplayState(is_multiplay);
526  }
527 
528  static void EnterGameplaySession()
529  {
530  string addr;
531  int port;
532  if ( GetGame().GetHostAddress( addr, port ) )
533  {
534  GetClientServices();
535  if ( m_ClientServices )
536  {
537  m_ClientServices.GetSessionService().EnterGameplaySessionAsync( addr, port );
538  SetMultiplayState(true);
539  }
540  }
541  }
542 
543  static void LeaveGameplaySession()
544  {
545  GetClientServices();
546  if ( m_ClientServices )
547  {
548  GetServersResultRow currentServerInfo = GetCurrentServerInfo();
549 
550  if ( currentServerInfo )
551  m_ClientServices.GetSessionService().LeaveGameplaySessionAsync(currentServerInfo.m_HostIp, currentServerInfo.m_HostPort);
552  else if ( m_CurrentServerIP != "" )
553  m_ClientServices.GetSessionService().LeaveGameplaySessionAsync(m_CurrentServerIP, m_CurrentServerPort);
554 
555  SetMultiplayState(false);
556  m_FirstFriendsLoad = true;
557 
558  if ( m_FriendsList )
559  m_FriendsList.Clear();
560  }
561  }
562 
563  static void SetGameplayActivity()
564  {
565  string addr;
566  int port;
567  if ( GetGame().GetHostAddress( addr, port ) )
568  {
569  GetClientServices();
570  if ( m_ClientServices )
571  {
572  m_ClientServices.GetSessionService().SetGameplayActivityAsync( addr, port );
573  }
574  }
575  }
576 
577  static void SetPendingInviteList( array<string> invitees )
578  {
579  string addr;
580  int port;
581  if ( GetGame().GetHostAddress( addr, port ) )
582  {
583  GetClientServices();
584  if ( m_ClientServices )
585  {
586  m_PendingInvites = invitees;
587  m_ClientServices.GetSessionService().InviteToGameplaySessionAsync( addr, port, GetPendingInviteList() );
588  }
589  }
590  else
591  {
592  m_PendingInvites = invitees;
593  }
594  }
595 
596  static array<string> GetPendingInviteList()
597  {
598  array<string> already_on_server = ClientData.GetSimplePlayerList();
599  if ( already_on_server && m_PendingInvites )
600  {
601  array<string> new_to_server = new array<string>;
602  foreach ( string invitee : m_PendingInvites )
603  {
604  if ( already_on_server.Find( invitee ) == -1 )
605  {
606  new_to_server.Insert( invitee );
607  }
608  }
609  return new_to_server;
610  }
611  else
612  {
613  return m_PendingInvites;
614  }
615  }
616 
617  static void ClearPendingInviteList( array<string> invitees )
618  {
619  delete m_PendingInvites;
620  }
621 
622  static int m_AutoConnectTries = 0;
623  static void AutoConnectToEmptyServer()
624  {
625  GetClientServices();
626  if ( m_ClientServices && m_AutoConnectTries == 0 )
627  {
628  m_AutoConnectTries = 1;
630  input.SetOfficial( true );
631  m_ClientServices.GetLobbyService().GetFirstServerWithEmptySlot( input );
632  }
633  }
634 
635  static GetServersResultRow GetRandomFreeResult( GetFirstServerWithEmptySlotResult results )
636  {
637  GetServersResultRow result;
639 
640  if ( results && results.m_Result && results.m_Result.m_Results && results.m_Result.m_Results.Count() > 0 )
641  {
642  foreach ( GetServersResultRow result_temp : results.m_Result.m_Results )
643  {
644  if ( result_temp.m_FreeSlots > 0 )
645  {
646  results_free.Insert( result_temp );
647  }
648  }
649  }
650 
651  return results_free.GetRandomElement();
652  }
653 
654  static void OnAutoConnectToEmptyServer( GetFirstServerWithEmptySlotResult result_list, EBiosError error )
655  {
656  if ( !ErrorCaught( error ) )
657  {
658  GetServersResultRow result = GetRandomFreeResult( result_list );
659  if ( result )
660  {
661  g_Game.ConnectFromServerBrowser( result.m_HostIp, result.m_HostPort );
662  m_AutoConnectTries = 0;
663  return;
664  }
665  else
666  {
667  GetGame().GetUIManager().ShowDialog( "#str_xbox_authentification_fail_title", "#str_xbox_authentification_fail", 232, DBT_OK, DBB_NONE, DMT_INFO, GetGame().GetUIManager().GetMenu() );
668  }
669  }
670 
671  if ( m_AutoConnectTries < 3 )
672  {
673  m_AutoConnectTries++;
675  input.SetOfficial( true );
676  m_ClientServices.GetLobbyService().GetFirstServerWithEmptySlot( input );
677  }
678  else
679  {
680  GetGame().GetUIManager().ShowDialog( "#str_xbox_authentification_fail_title", "#xbox_authentification_fail", 232, DBT_OK, DBB_NONE, DMT_INFO, GetGame().GetUIManager().GetMenu() );
681  }
682  }
683 
684  static void GetServerModList( string server_id )
685  {
686  GetClientServices();
687  if ( m_ClientServices )
688  {
689  m_ClientServices.GetLobbyService().GetServerModList( server_id );
690  }
691  }
692 
693  static void OnGetServerModList( GetServerModListResult result_list, EBiosError error )
694  {
695  if ( !ErrorCaught( error ) )
696  {
697  m_ServerModLoadAsyncInvoker.Invoke( result_list );
698  }
699  }
700 
701  static bool IsGameTrial( bool sim )
702  {
703  #ifdef PLATFORM_XBOX
704  #ifndef PLATFORM_WINDOWS
705  if ( m_TrialService )
706  return m_TrialService.IsGameTrial( sim );
707  #endif
708  #endif
709  return false;
710  }
711 
712  static bool IsGameActive( bool sim )
713  {
714  #ifdef PLATFORM_XBOX
715  #ifndef PLATFORM_WINDOWS
716  if ( m_TrialService )
717  return m_TrialService.IsGameActive( sim );
718  #endif
719  #endif
720  return false;
721  }
722 
723  static bool CheckUpdate()
724  {
725  GetClientServices();
726  if ( m_ClientServices )
727  {
728  EBiosError error = m_ClientServices.GetPackageService().CheckUpdateAsync();
729 
730  if ( !error )
731  {
732  return true;
733  }
734  }
735 
736  return false;
737  }
738 
739  static void PromptUpdate()
740  {
741  GetClientServices();
742  if ( m_ClientServices )
743  {
744  m_ClientServices.GetPackageService().PromptUpdateAsync();
745  }
746  }
747 }
GetGame
proto native CGame GetGame()
BiosClientServices
BiosClientServices class provides individual online services.
Definition: biosclientservices.c:9
Error
void Error(string err)
Messagebox with error message.
Definition: endebug.c:90
BiosFriendInfo
BiosFriendInfo represents friend information.
Definition: biossocialservice.c:4
NotificationSystem
Definition: notificationsystem.c:69
ScriptInputUserData
Definition: gameplay.c:120
ClientData
Definition: clientdata.c:1
TrialService
TrialService is used to query if the game is trial version or not.
Definition: trialservice.c:3
DebugPrint
Definition: debugprint.c:1
ErrorCategory
ErrorCategory
ErrorCategory - To decide what ErrorHandlerModule needs to be called and easily identify where it cam...
Definition: errormodulehandler.c:4
map
map
Definition: controlsxboxnew.c:3
BiosPrivacyPermissionResult
BiosPrivacyPermissionResult represents the per permission result of the GetPermissionsAsync reqeust.
Definition: biosprivacyservice.c:27
g_Game
DayZGame g_Game
Definition: dayzgame.c:3727
EBiosError
EBiosError
Possible Error codes for bios API. This is the list of errors that can be returned from bios API....
Definition: bioserrormodule.c:6
GetServersResult
GetServersResult the output structure of the GetServers operation.
Definition: bioslobbyservice.c:224
GetFirstServerWithEmptySlotResult
Definition: bioslobbyservice.c:188
EBiosPrivacyPrivilege
EBiosPrivacyPrivilege
EBiosPrivacyPrivilege represents possible privacy privileges.
Definition: biosprivacyservice.c:17
BiosUserManager
Definition: biosusermanager.c:16
array< string >
EBiosPrivacyPermission
EBiosPrivacyPermission
EBiosPrivacyPermission represents possible privacy permissions.
Definition: biosprivacyservice.c:5
GetServerModListResult
Definition: bioslobbyservice.c:24
BiosPrivacyUidResult
BiosPrivacyUidResult represents the per user result of the GetPermissionsAsync request.
Definition: biosprivacyservice.c:43
SyncPlayer
Definition: syncplayer.c:1
NotificationType
NotificationType
DEPRECATED (moved into NotificationSystem)
Definition: notificationsystem.c:3
GetFirstServerWithEmptySlotInput
GetServersInput the input structure of the GetServers operation.
Definition: bioslobbyservice.c:194
BiosPrivacyUidResultArray
array< ref BiosPrivacyUidResult > BiosPrivacyUidResultArray
Definition: biosprivacyservice.c:49
GetServersInput
GetServersInput the input structure of the GetServers operation.
Definition: bioslobbyservice.c:234
BiosUser
Definition: biosusermanager.c:8
OnlineServices
Definition: onlineservices.c:1
INPUT_UDT_USER_MUTE_XBOX
const int INPUT_UDT_USER_MUTE_XBOX
Definition: _constants.c:13
ErrorModuleHandler
The error handler itself, for managing and distributing errors to modules Manages the ErrorHandlerMod...
Definition: errormodulehandler.c:28
ScriptInvoker
ScriptInvoker Class provide list of callbacks usage:
Definition: tools.c:115