//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: interface to user account information in Steam // //============================================================================= #ifndef ISTEAMUSER_H #define ISTEAMUSER_H #ifdef _WIN32 #pragma once #endif #include "isteamclient.h" // structure that contains client callback data // see callbacks documentation for more details #if defined( VALVE_CALLBACK_PACK_SMALL ) #pragma pack( push, 4 ) #elif defined( VALVE_CALLBACK_PACK_LARGE ) #pragma pack( push, 8 ) #else #error isteamclient.h must be included #endif struct CallbackMsg_t { HSteamUser m_hSteamUser; int m_iCallback; uint8 *m_pubParam; int m_cubParam; }; #pragma pack( pop ) // reference to a steam call, to filter results by typedef int32 HSteamCall; //----------------------------------------------------------------------------- // Purpose: Functions for accessing and manipulating a steam account // associated with one client instance //----------------------------------------------------------------------------- class ISteamUser { public: // returns the HSteamUser this interface represents // this is only used internally by the API, and by a few select interfaces that support multi-user virtual HSteamUser GetHSteamUser() = 0; // returns true if the Steam client current has a live connection to the Steam servers. // If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy. // The Steam client will automatically be trying to recreate the connection as often as possible. virtual bool BLoggedOn() = 0; // returns the CSteamID of the account currently logged into the Steam client // a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API virtual CSteamID GetSteamID() = 0; // Multiplayer Authentication functions // InitiateGameConnection() starts the state machine for authenticating the game client with the game server // It is the client portion of a three-way handshake between the client, the game server, and the steam servers // // Parameters: // void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token. // int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes. // CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client // CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( ) // uint32 unIPServer, uint16 usPortServer - the IP address of the game server // bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running) // // return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed // The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process. virtual int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0; // notify of disconnect // needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0; // Legacy functions // used by only a few games to track usage events virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0; // get the local storage folder for current Steam account to write application data, e.g. save games, configs etc. // this will usually be something like "C:\Progam Files\Steam\userdata\\\local" virtual bool GetUserDataFolder( char *pchBuffer, int cubBuffer ) = 0; // Starts voice recording. Once started, use GetVoice() to get the data virtual void StartVoiceRecording( ) = 0; // Stops voice recording. Because people often release push-to-talk keys early, the system will keep recording for // a little bit after this function is called. GetVoice() should continue to be called until it returns // k_eVoiceResultNotRecording virtual void StopVoiceRecording( ) = 0; // Determine the amount of captured audio data that is available in bytes. // This provides both the compressed and uncompressed data. Please note that the uncompressed // data is not the raw feed from the microphone: data may only be available if audible // levels of speech are detected. // nUncompressedVoiceDesiredSampleRate is necessary to know the number of bytes to return in pcbUncompressed - can be set to 0 if you don't need uncompressed (the usual case) // If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nUncompressedVoiceDesiredSampleRate virtual EVoiceResult GetAvailableVoice(uint32 *pcbCompressed, uint32 *pcbUncompressed, uint32 nUncompressedVoiceDesiredSampleRate) = 0; // Gets the latest voice data from the microphone. Compressed data is an arbitrary format, and is meant to be handed back to // DecompressVoice() for playback later as a binary blob. Uncompressed data is 16-bit, signed integer, 11025Hz PCM format. // Please note that the uncompressed data is not the raw feed from the microphone: data may only be available if audible // levels of speech are detected, and may have passed through denoising filters, etc. // This function should be called as often as possible once recording has started; once per frame at least. // nBytesWritten is set to the number of bytes written to pDestBuffer. // nUncompressedBytesWritten is set to the number of bytes written to pUncompressedDestBuffer. // You must grab both compressed and uncompressed here at the same time, if you want both. // Matching data that is not read during this call will be thrown away. // GetAvailableVoice() can be used to determine how much data is actually available. // If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nUncompressedVoiceDesiredSampleRate virtual EVoiceResult GetVoice( bool bWantCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, bool bWantUncompressed, void *pUncompressedDestBuffer, uint32 cbUncompressedDestBufferSize, uint32 *nUncompressBytesWritten, uint32 nUncompressedVoiceDesiredSampleRate ) = 0; // Decompresses a chunk of compressed data produced by GetVoice(). // nBytesWritten is set to the number of bytes written to pDestBuffer unless the return value is k_EVoiceResultBufferTooSmall. // In that case, nBytesWritten is set to the size of the buffer required to decompress the given // data. The suggested buffer size for the destination buffer is 22 kilobytes. // The output format of the data is 16-bit signed at the requested samples per second. // If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nDesiredSampleRate virtual EVoiceResult DecompressVoice( const void *pCompressed, uint32 cbCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, uint32 nDesiredSampleRate ) = 0; // This returns the frequency of the voice data as it's stored internally; calling DecompressVoice() with this size will yield the best results virtual uint32 GetVoiceOptimalSampleRate() = 0; // Retrieve ticket to be sent to the entity who wishes to authenticate you. // pcbTicket retrieves the length of the actual ticket. virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0; // Authenticate ticket from entity steamID to be sure it is valid and isnt reused // Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse ) virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0; // Stop tracking started by BeginAuthSession - called when no longer playing game with this entity virtual void EndAuthSession( CSteamID steamID ) = 0; // Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0; // After receiving a user's authentication data, and passing it to BeginAuthSession, use this function // to determine if the user owns downloadable content specified by the provided AppID. virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0; // returns true if this users looks like they are behind a NAT device. Only valid once the user has connected to steam // (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT. virtual bool BIsBehindNAT() = 0; // set data to be replicated to friends so that they can join your game // CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client // uint32 unIPServer, uint16 usPortServer - the IP address of the game server virtual void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer ) = 0; // Requests a ticket encrypted with an app specific shared key // pDataToInclude, cbDataToInclude will be encrypted into the ticket // ( This is asynchronous, you must wait for the ticket to be completed by the server ) virtual SteamAPICall_t RequestEncryptedAppTicket( void *pDataToInclude, int cbDataToInclude ) = 0; // retrieve a finished ticket virtual bool GetEncryptedAppTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0; #ifdef _PS3 // Initiates PS3 Logon request using just PSN ticket. // // PARAMS: bInteractive - If set tells Steam to go ahead and show the PS3 NetStart dialog if needed to // prompt the user for network setup/PSN logon before initiating the Steam side of the logon. // // Listen for SteamServersConnected_t or SteamServerConnectFailure_t for status. SteamServerConnectFailure_t // may return with EResult k_EResultExternalAccountUnlinked if the PSN account is unknown to Steam. You should // then call LogOnAndLinkSteamAccountToPSN() after prompting the user for credentials to establish a link. // Future calls to LogOn() after the one time link call should succeed as long as the user is connected to PSN. virtual void LogOn( bool bInteractive ) = 0; // Initiates a request to logon with a specific steam username/password and create a PSN account link at // the same time. Should call this only if LogOn() has failed and indicated the PSN account is unlinked. // // PARAMS: bInteractive - If set tells Steam to go ahead and show the PS3 NetStart dialog if needed to // prompt the user for network setup/PSN logon before initiating the Steam side of the logon. pchUserName // should be the users Steam username, and pchPassword should be the users Steam password. // // Listen for SteamServersConnected_t or SteamServerConnectFailure_t for status. SteamServerConnectFailure_t // may return with EResult k_EResultOtherAccountAlreadyLinked if already linked to another account. virtual void LogOnAndLinkSteamAccountToPSN( bool bInteractive, const char *pchUserName, const char *pchPassword ) = 0; // Final logon option for PS3, this logs into an existing account if already linked, but if not already linked // creates a new account using the info in the PSN ticket to generate a unique account name. The new account is // then linked to the PSN ticket. This is the faster option for new users who don't have an existing Steam account // to get into multiplayer. // // PARAMS: bInteractive - If set tells Steam to go ahead and show the PS3 NetStart dialog if needed to // prompt the user for network setup/PSN logon before initiating the Steam side of the logon. virtual void LogOnAndCreateNewSteamAccountIfNeeded( bool bInteractive ) = 0; // Returns a special SteamID that represents the user's PSN information. Can be used to query the user's PSN avatar, // online name, etc. through the standard Steamworks interfaces. virtual CSteamID GetConsoleSteamID() = 0; #endif }; #define STEAMUSER_INTERFACE_VERSION "SteamUser016" // callbacks #if defined( VALVE_CALLBACK_PACK_SMALL ) #pragma pack( push, 4 ) #elif defined( VALVE_CALLBACK_PACK_LARGE ) #pragma pack( push, 8 ) #else #error isteamclient.h must be included #endif //----------------------------------------------------------------------------- // Purpose: called when a connections to the Steam back-end has been established // this means the Steam client now has a working connection to the Steam servers // usually this will have occurred before the game has launched, and should // only be seen if the user has dropped connection due to a networking issue // or a Steam server update //----------------------------------------------------------------------------- struct SteamServersConnected_t { enum { k_iCallback = k_iSteamUserCallbacks + 1 }; }; //----------------------------------------------------------------------------- // Purpose: called when a connection attempt has failed // this will occur periodically if the Steam client is not connected, // and has failed in it's retry to establish a connection //----------------------------------------------------------------------------- struct SteamServerConnectFailure_t { enum { k_iCallback = k_iSteamUserCallbacks + 2 }; EResult m_eResult; }; //----------------------------------------------------------------------------- // Purpose: called if the client has lost connection to the Steam servers // real-time services will be disabled until a matching SteamServersConnected_t has been posted //----------------------------------------------------------------------------- struct SteamServersDisconnected_t { enum { k_iCallback = k_iSteamUserCallbacks + 3 }; EResult m_eResult; }; //----------------------------------------------------------------------------- // Purpose: Sent by the Steam server to the client telling it to disconnect from the specified game server, // which it may be in the process of or already connected to. // The game client should immediately disconnect upon receiving this message. // This can usually occur if the user doesn't have rights to play on the game server. //----------------------------------------------------------------------------- struct ClientGameServerDeny_t { enum { k_iCallback = k_iSteamUserCallbacks + 13 }; uint32 m_uAppID; uint32 m_unGameServerIP; uint16 m_usGameServerPort; uint16 m_bSecure; uint32 m_uReason; }; //----------------------------------------------------------------------------- // Purpose: called when the callback system for this client is in an error state (and has flushed pending callbacks) // When getting this message the client should disconnect from Steam, reset any stored Steam state and reconnect. // This usually occurs in the rare event the Steam client has some kind of fatal error. //----------------------------------------------------------------------------- struct IPCFailure_t { enum { k_iCallback = k_iSteamUserCallbacks + 17 }; enum EFailureType { k_EFailureFlushedCallbackQueue, k_EFailurePipeFail, }; uint8 m_eFailureType; }; //----------------------------------------------------------------------------- // callback for BeginAuthSession //----------------------------------------------------------------------------- struct ValidateAuthTicketResponse_t { enum { k_iCallback = k_iSteamUserCallbacks + 43 }; CSteamID m_SteamID; EAuthSessionResponse m_eAuthSessionResponse; }; //----------------------------------------------------------------------------- // Purpose: called when a user has responded to a microtransaction authorization request //----------------------------------------------------------------------------- struct MicroTxnAuthorizationResponse_t { enum { k_iCallback = k_iSteamUserCallbacks + 52 }; uint32 m_unAppID; // AppID for this microtransaction uint64 m_ulOrderID; // OrderID provided for the microtransaction uint8 m_bAuthorized; // if user authorized transaction }; //----------------------------------------------------------------------------- // Purpose: Result from RequestEncryptedAppTicket //----------------------------------------------------------------------------- struct EncryptedAppTicketResponse_t { enum { k_iCallback = k_iSteamUserCallbacks + 54 }; EResult m_eResult; }; //----------------------------------------------------------------------------- // callback for GetAuthSessionTicket //----------------------------------------------------------------------------- struct GetAuthSessionTicketResponse_t { enum { k_iCallback = k_iSteamUserCallbacks + 63 }; HAuthTicket m_hAuthTicket; EResult m_eResult; }; //----------------------------------------------------------------------------- // Purpose: sent to your game in response to a steam://gamewebcallback/ command //----------------------------------------------------------------------------- struct GameWebCallback_t { enum { k_iCallback = k_iSteamUserCallbacks + 64 }; char m_szURL[256]; }; #pragma pack( pop ) #endif // ISTEAMUSER_H