public PICSChanges(CallbackManager manager) : base(manager) { if (Settings.IsFullRun) { PreviousChangeNumber = 1; // Request everything manager.Subscribe<SteamApps.PICSChangesCallback>(OnPICSChangesFullRun); return; } manager.Subscribe<SteamApps.PICSChangesCallback>(OnPICSChanges); using (var db = Database.GetConnection()) { BillingTypeKey = db.ExecuteScalar<uint>("SELECT `ID` FROM `KeyNamesSubs` WHERE `Name` = 'root_billingtype'"); PreviousChangeNumber = db.ExecuteScalar<uint>("SELECT `ChangeID` FROM `Changelists` ORDER BY `ChangeID` DESC LIMIT 1"); Log.WriteInfo("PICSChanges", "Previous changelist was {0}", PreviousChangeNumber); } if (PreviousChangeNumber == 0) { Log.WriteWarn("PICSChanges", "Looks like there are no changelists in the database."); Log.WriteWarn("PICSChanges", "If you want to fill up your database first, restart with \"FullRun\" setting set to 1."); } }
public GCClient() { SteamClient = new SteamClient(); SteamClient.AddHandler( new SteamGames() ); CallbackManager = new CallbackManager( SteamClient ); SteamUser = SteamClient.GetHandler<SteamUser>(); SteamGameCoordinator = SteamClient.GetHandler<SteamGameCoordinator>(); SteamApps = SteamClient.GetHandler<SteamApps>(); SteamGames = SteamClient.GetHandler<SteamGames>(); SteamFriends = SteamClient.GetHandler<SteamFriends>(); new Callback<SteamClient.ConnectedCallback>( OnConnected, CallbackManager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, CallbackManager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, CallbackManager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, CallbackManager ); new Callback<SteamApps.LicenseListCallback>( OnLicenseList, CallbackManager ); new Callback<SteamGameCoordinator.MessageCallback>( OnGCMessage, CallbackManager ); new JobCallback<SteamApps.AppOwnershipTicketCallback>( OnAppTicket, CallbackManager ); }
public FreeLicense(CallbackManager manager) : base(manager) { PackageRegex = new Regex("RemoveFreeLicense\\( ?(?<subid>[0-9]+), ?'(?<name>.+)' ?\\)", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture); manager.Subscribe<SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback); }
public PICSTokens(CallbackManager manager) : base(manager) { manager.Register(new Callback<SteamApps.PICSTokensCallback>(OnPICSTokens)); Reload(); }
public PICSChanges(CallbackManager manager) : base(manager) { if (Settings.IsFullRun) { PreviousChangeNumber = 1; // Request everything manager.Register(new Callback<SteamApps.PICSChangesCallback>(OnPICSChangesFullRun)); return; } manager.Register(new Callback<SteamApps.PICSChangesCallback>(OnPICSChanges)); using (MySqlDataReader Reader = DbWorker.ExecuteReader("SELECT `ChangeID` FROM `Changelists` ORDER BY `ChangeID` DESC LIMIT 1")) { if (Reader.Read()) { PreviousChangeNumber = Reader.GetUInt32("ChangeID"); Log.WriteInfo("PICSChanges", "Previous changelist was {0}", PreviousChangeNumber); } } if (PreviousChangeNumber == 0) { Log.WriteWarn("PICSChanges", "Looks like there are no changelists in the database."); Log.WriteWarn("PICSChanges", "If you want to fill up your database first, restart with \"FullRun\" setting set to 1."); } }
static void LogIn() { steamClient = new SteamClient(); callbackManager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); steamTrading = steamClient.GetHandler<SteamTrading>(); new Callback<SteamClient.ConnectedCallback>(OnConnect,callbackManager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, callbackManager); new Callback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth, callbackManager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, callbackManager); new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, callbackManager); new Callback<SteamFriends.FriendMsgCallback>(OnChatMessage, callbackManager); new Callback<SteamFriends.FriendsListCallback>(OnFriendInvite, callbackManager); new Callback<SteamTrading.TradeProposedCallback>(OnTradeOffer, callbackManager); new Callback<SteamTrading.SessionStartCallback>(OnTradeWindow, callbackManager); new Callback<SteamTrading.TradeResultCallback>(OnTradeResult, callbackManager); isRunning = true; Console.WriteLine("Attempting to connect to steam..."); steamClient.Connect(); while(isRunning) { callbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } Console.ReadKey(); }
public GameCoordinator(uint appID, SteamClient steamClient, CallbackManager callbackManager) { // Map gc messages to our callback functions GCMessageMap = new Dictionary<uint, Action<IPacketGCMsg>> { { (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, OnClientWelcome }, { (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate }, { (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage }, { (uint)EGCBaseClientMsg.k_EMsgGCClientConnectionStatus, OnClientConnectionStatus }, { (uint)4008 /* TF2's k_EMsgGCClientGoodbye */, OnClientConnectionStatus } }; this.AppID = appID; this.SteamClient = steamClient; this.SteamGameCoordinator = SteamClient.GetHandler<SteamGameCoordinator>(); this.Name = string.Format("GC {0}", appID); // Make sure Steam knows we're playing the game Timer = new System.Timers.Timer(); Timer.Elapsed += OnTimerPlayGame; Timer.Interval = TimeSpan.FromMinutes(5).TotalMilliseconds; Timer.Start(); Timer = new System.Timers.Timer(); Timer.Elapsed += OnTimer; callbackManager.Register(new Callback<SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage)); }
public SteamBot(string newUser, string newPass) { // Bot user and password user = newUser; pass = newPass; // create our steamclient instance steamClient = new SteamClient( System.Net.Sockets.ProtocolType.Tcp ); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get the steam friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler<SteamFriends>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); // we use the following callbacks for friends related activities new Callback<SteamUser.AccountInfoCallback>( OnAccountInfo, manager ); new Callback<SteamFriends.FriendsListCallback>( OnFriendsList, manager ); new Callback<SteamFriends.FriendMsgCallback> (OnFriendMessage, manager); // initiate the connection steamClient.Connect(); // Make sure the main loop runs isRunning = true; }
public PICSTokens(CallbackManager manager) : base(manager) { manager.Subscribe<SteamApps.PICSTokensCallback>(OnPICSTokens); Reload(); }
private static void Login() { steamClient = new SteamClient(); callBackManager = new CallbackManager(steamClient); steamFriends = steamClient.GetHandler<SteamFriends>(); steamUser = steamClient.GetHandler<SteamUser>(); callBackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); callBackManager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedIn); callBackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); callBackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); callBackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnMsgRecieved); callBackManager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo); callBackManager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList); callBackManager.Subscribe<SteamFriends.FriendAddedCallback>(OnFriendAdded); callBackManager.Subscribe<SteamFriends.PersonaStateCallback>(OnFriendPersonaChange); SteamDirectory.Initialize().Wait(); steamClient.Connect(); isRunning = true; while (isRunning) { callBackManager.RunWaitCallbacks(TimeSpan.FromSeconds(0.5)); } Console.ReadKey(); }
public GameCoordinator(SteamClient steamClient, CallbackManager manager) { SessionMap = new Dictionary<uint, SessionInfo>(); // Map gc messages to our callback functions MessageMap = new Dictionary<uint, Action<uint, IPacketGCMsg>> { { (uint)EGCBaseClientMsg.k_EMsgGCClientConnectionStatus, OnConnectionStatus }, { (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, OnWelcome }, { (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate }, { (uint)EGCItemMsg.k_EMsgGCClientVersionUpdated, OnVersionUpdate }, { (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage }, // TF2 specific messages { k_EMsgGCClientGoodbye, OnConnectionStatus }, { (uint)EGCItemMsg.k_EMsgGCGoldenWrenchBroadcast, OnWrenchBroadcast }, { k_EMsgGCTFSpecificItemBroadcast, OnItemBroadcast }, }; SteamGameCoordinator = steamClient.GetHandler<SteamGameCoordinator>(); SessionTimer = new Timer(); SessionTimer.Interval = TimeSpan.FromSeconds(30).TotalMilliseconds; SessionTimer.Elapsed += OnSessionTick; SessionTimer.Start(); manager.Subscribe<SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage); manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); }
public Steam() { Client = new SteamClient(); User = Client.GetHandler<SteamUser>(); Apps = Client.GetHandler<SteamApps>(); Friends = Client.GetHandler<SteamFriends>(); UserStats = Client.GetHandler<SteamUserStats>(); CallbackManager = new CallbackManager(Client); Client.AddHandler(new ReadMachineAuth()); new Connection(CallbackManager); new PICSProductInfo(CallbackManager); new PICSTokens(CallbackManager); new LicenseList(CallbackManager); new WebAuth(CallbackManager); new FreeLicense(CallbackManager); if (!Settings.IsFullRun) { new AccountInfo(CallbackManager); new ClanState(CallbackManager); new ChatMemberInfo(CallbackManager); new GameCoordinator(Client, CallbackManager); new Watchdog(); } PICSChanges = new PICSChanges(CallbackManager); DepotProcessor = new DepotProcessor(Client, CallbackManager); IsRunning = true; }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "SendMessage: No username and password specified!" ); return; } // exit gracefully if possible Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) { e.Cancel = true; isRunning = false; }; var url = "http://localhost:3131"; var host = new NancyHost(new Uri(url)); host.Start(); Console.WriteLine ("Server now running on: " + url); // save our logon details user = args[ 0 ]; pass = args[ 1 ]; manager = new CallbackManager( Steam3.SteamClient ); new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // we use the following callbacks for friends related activities new Callback<SteamUser.AccountInfoCallback>( OnAccountInfo, manager ); new Callback<SteamFriends.FriendsListCallback>( OnFriendsList, manager ); new Callback<SteamFriends.PersonaStateCallback>( OnPersonaState, manager ); new Callback<SteamFriends.FriendAddedCallback>( OnFriendAdded, manager ); new Callback<SteamFriends.FriendMsgCallback>( OnMsgReceived, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection Steam3.SteamClient.Connect( false ); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } Console.WriteLine( "Disconnecting from Steam..." ); Steam3.SteamUser.LogOff(); Steam3.SteamClient.Disconnect(); host.Stop(); host.Stop(); }
public Login(SteamNerd steamNerd, CallbackManager manager) { _steamNerd = steamNerd; manager.Subscribe<SteamClient.ConnectedCallback>(OnConnect); manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnect); manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe<SteamUser.LoginKeyCallback>(OnLoginKey); }
static void Main( string[] args ) { // install our debug listeners for this example // install an instance of our custom listener DebugLog.AddListener( new MyListener() ); // install a listener as an anonymous method // this call is commented as it would be redundant to install a second listener that also displays messages to the console // DebugLog.AddListener( ( category, msg ) => Console.WriteLine( "AnonymousMethod - {0}: {1}", category, msg ) ); // Enable DebugLog in release builds DebugLog.Enabled = true; if ( args.Length < 2 ) { Console.WriteLine( "Sample4: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
static void Main(string[] args) { // Print program information. Console.WriteLine("SteamIdler, 'run' games without steam.\n(C) No STEAMGUARD Support"); // Check for username and password arguments from stdin. if (args.Length < 3) { // Print usage and quit. Console.WriteLine("usage: <username> <password> <appID> [...]"); return; } // Set username and password from stdin. Username = args[0]; Password = args[1]; // Add all game application IDs to list. foreach (string GameAppID in args) { int AppID; if (int.TryParse(GameAppID, out AppID)) { AppIDs.Add(Convert.ToInt32(GameAppID)); } } // Create SteamClient interface and CallbackManager. steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); manager = new CallbackManager(steamClient); // Get the steamuser handler, which is used for logging on after successfully connecting. steamUser = steamClient.GetHandler<SteamUser>(); // Get the steam friends handler, which is used for interacting with friends on the network after logging on. steamFriends = steamClient.GetHandler<SteamFriends>(); // Register Steam callbacks. new Callback<SteamClient.ConnectedCallback>(OnConnected, manager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff, manager); new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, manager); // Set the program as running. Console.WriteLine(":: Connecting to Steam.."); isRunning = true; // Connect to Steam. steamClient.Connect(); // Create our callback handling loop. while (isRunning) { // In order for the callbacks to get routed, they need to be handled by the manager. manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
static void Main(string[] args) { Logger.filename = "RelayBot.log"; log = Logger.GetLogger(); steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); bot = new Bot(steamUser, steamFriends, steamClient); manager.Subscribe<SteamClient.ConnectedCallback>(bot.OnConnected); manager.Subscribe<SteamClient.DisconnectedCallback>(bot.OnDisconnected); manager.Subscribe<SteamUser.LoggedOnCallback>(bot.OnLoggedOn); manager.Subscribe<SteamUser.LoggedOffCallback>(bot.OnLoggedOff); manager.Subscribe<SteamUser.AccountInfoCallback>(bot.OnAccountInfo); manager.Subscribe<SteamFriends.FriendsListCallback>(bot.OnFriendsList); manager.Subscribe<SteamFriends.FriendAddedCallback>(bot.OnFriendAdded); manager.Subscribe<SteamFriends.ChatInviteCallback>(bot.OnChatInvite); manager.Subscribe<SteamFriends.ChatEnterCallback>(bot.OnChatEnter); manager.Subscribe<SteamFriends.FriendMsgCallback>(bot.OnFriendMessage); manager.Subscribe<SteamFriends.ChatMsgCallback>(bot.OnChatroomMessage); manager.Subscribe<SteamFriends.ChatMemberInfoCallback>(bot.OnMemberInfo); manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(bot.OnMachineAuth); bot.isRunning = true; log.Info("Connecting to Steam..."); steamClient.Connect(); //callback loop while (bot.isRunning) { try { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } catch (Exception e) { Logger.filename = "RelayBot.log"; log.Error(String.Format("Caught exception: {0}\nMessage: {1}\nStack trace: {2}", e.GetType().ToString(), e.Message, e.StackTrace)); } } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample8: No username and password specified!" ); return; } // save our logon details user = args[0]; pass = args[1]; // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get the steam unified messages handler, which is used for sending and receiving responses from the unified service api steamUnifiedMessages = steamClient.GetHandler<SteamUnifiedMessages>(); // we also want to create our local service interface, which will help us build requests to the unified api playerService = steamUnifiedMessages.CreateService<IPlayer>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified manager.Subscribe<SteamClient.ConnectedCallback>( OnConnected ); manager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected ); manager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn ); manager.Subscribe<SteamUser.LoggedOffCallback>( OnLoggedOff ); // we use the following callbacks for unified service responses manager.Subscribe<SteamUnifiedMessages.ServiceMethodResponse>( OnMethodResponse ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample9: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get our steamapps handler, we'll use this as an example of how async jobs can be handled steamApps = steamClient.GetHandler<SteamApps>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified manager.Subscribe<SteamClient.ConnectedCallback>( OnConnected ); manager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected ); manager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn ); manager.Subscribe<SteamUser.LoggedOffCallback>( OnLoggedOff ); // notice that we're not subscribing to the SteamApps.PICSProductInfoCallback callback here (or other SteamApps callbacks) // since this sample is using the async job directly, we no longer need to subscribe to the callback. // however, if we still wish to use callbacks (or have existing code which subscribes to callbacks, they will // continue to operate alongside direct async job handling. (i.e.: steamclient will still post callbacks for // any async jobs that are completed) isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
public Steam3Session( SteamUser.LogOnDetails details ) { this.logonDetails = details; this.authenticatedUser = details.Username != null; this.credentials = new Credentials(); this.bConnected = false; this.bConnecting = false; this.bAborted = false; this.seq = 0; this.AppTickets = new Dictionary<uint, byte[]>(); this.AppTokens = new Dictionary<uint, ulong>(); this.DepotKeys = new Dictionary<uint, byte[]>(); this.CDNAuthTokens = new Dictionary<Tuple<uint, string>, SteamApps.CDNAuthTokenCallback>(); this.AppInfo = new Dictionary<uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>(); this.PackageInfo = new Dictionary<uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>(); this.steamClient = new SteamClient(); this.steamUser = this.steamClient.GetHandler<SteamUser>(); this.steamApps = this.steamClient.GetHandler<SteamApps>(); this.callbacks = new CallbackManager(this.steamClient); this.callbacks.Subscribe<SteamClient.ConnectedCallback>(ConnectedCallback); this.callbacks.Subscribe<SteamClient.DisconnectedCallback>(DisconnectedCallback); this.callbacks.Subscribe<SteamUser.LoggedOnCallback>(LogOnCallback); this.callbacks.Subscribe<SteamUser.SessionTokenCallback>(SessionTokenCallback); this.callbacks.Subscribe<SteamApps.LicenseListCallback>(LicenseListCallback); this.callbacks.Subscribe<SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback); Console.Write( "Connecting to Steam3..." ); if ( authenticatedUser ) { FileInfo fi = new FileInfo(String.Format("{0}.sentryFile", logonDetails.Username)); if (ConfigStore.TheConfig.SentryData != null && ConfigStore.TheConfig.SentryData.ContainsKey(logonDetails.Username)) { logonDetails.SentryFileHash = Util.SHAHash(ConfigStore.TheConfig.SentryData[logonDetails.Username]); } else if (fi.Exists && fi.Length > 0) { var sentryData = File.ReadAllBytes(fi.FullName); logonDetails.SentryFileHash = Util.SHAHash(sentryData); ConfigStore.TheConfig.SentryData[logonDetails.Username] = sentryData; ConfigStore.Save(); } } Connect(); }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample3: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // add our custom handler to our steamclient steamClient.AddHandler( new MyHandler() ); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // now get an instance of our custom handler myHandler = steamClient.GetHandler<MyHandler>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // handle our own custom callback new Callback<MyHandler.MyCallback>( OnMyCallback, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample5: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient( System.Net.Sockets.ProtocolType.Tcp ); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get the steam friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler<SteamFriends>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // we use the following callbacks for friends related activities new Callback<SteamUser.AccountInfoCallback>( OnAccountInfo, manager ); new Callback<SteamFriends.FriendsListCallback>( OnFriendsList, manager ); new Callback<SteamFriends.PersonaStateCallback>( OnPersonaState, manager ); new Callback<SteamFriends.FriendAddedCallback>( OnFriendAdded, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect( false ); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
public void Init() { FacebookLogger.Instance = new FacebookTestLogger(); Type type = this.GetType(); var callbackManager = new CallbackManager(); if (Attribute.GetCustomAttribute(type, typeof(AndroidTestAttribute)) != null) { var mockWrapper = new MockAndroid(); Constants.CurrentPlatform = FacebookUnityPlatform.Android; var facebook = new AndroidFacebook(mockWrapper, callbackManager); this.Mock = mockWrapper; this.Mock.Facebook = facebook; FB.FacebookImpl = facebook; } else if (Attribute.GetCustomAttribute(type, typeof(IOSTestAttribute)) != null) { var mockWrapper = new MockIOS(); Constants.CurrentPlatform = FacebookUnityPlatform.IOS; var facebook = new IOSFacebook(mockWrapper, callbackManager); this.Mock = mockWrapper; this.Mock.Facebook = facebook; FB.FacebookImpl = facebook; } else if (Attribute.GetCustomAttribute(type, typeof(CanvasTestAttribute)) != null) { var mockWrapper = new MockCanvas(); Constants.CurrentPlatform = FacebookUnityPlatform.WebGL; var facebook = new CanvasFacebook(mockWrapper, callbackManager); this.Mock = mockWrapper; this.Mock.Facebook = facebook; FB.FacebookImpl = facebook; } else if (Attribute.GetCustomAttribute(type, typeof(EditorTestAttribute)) != null) { var mockWrapper = new MockEditor(); // The editor works for all platforms but claim to be android for testing. Constants.CurrentPlatform = FacebookUnityPlatform.Android; var facebook = new EditorFacebook(mockWrapper, callbackManager); this.Mock = mockWrapper; this.Mock.Facebook = facebook; FB.FacebookImpl = facebook; } else { throw new Exception("Failed to specify platform specified on test class"); } this.OnInit(); }
public Connection(CallbackManager manager) : base(manager) { ReconnectionTimer = new Timer(); ReconnectionTimer.AutoReset = false; ReconnectionTimer.Elapsed += Reconnect; ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds; manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); }
public static void Main() { Log.WriteInfo("Program", "Starting..."); Console.CancelKeyPress += delegate { Log.WriteInfo("Program", "Exiting..."); try { Client.Disconnect(); } catch { Log.WriteError("Steam", "Failed to disconnect from Steam"); } IsRunning = false; }; TwitterToken = new Token( ConfigurationManager.AppSettings["token_AccessToken"], ConfigurationManager.AppSettings["token_AccessTokenSecret"], ConfigurationManager.AppSettings["token_ConsumerKey"], ConfigurationManager.AppSettings["token_ConsumerSecret"] ); ITokenRateLimits tokenLimits = TwitterToken.GetRateLimit(); Log.WriteInfo("Twitter", "Remaining Twitter requests: {0} of {1}", tokenLimits.ApplicationRateLimitStatusLimit.Remaining, tokenLimits.ApplicationRateLimitStatusLimit.Limit); Timer.Elapsed += OnTimer; Timer.Interval = TimeSpan.FromMinutes(10).TotalMilliseconds; var CallbackManager = new CallbackManager(Client); CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected)); CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected)); CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn)); CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff)); CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo)); CallbackManager.Register(new Callback<SteamFriends.ClanStateCallback>(OnClanState)); Client.Connect(); while (IsRunning) { CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(5)); } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample5: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get the steam friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler<SteamFriends>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // this callback is triggered when the steam servers wish for the client to store the sentry file new JobCallback<SteamUser.UpdateMachineAuthCallback>( OnMachineAuth, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
public UGCHandler( CallbackManager manager ) : base(manager) { try { Directory.CreateDirectory( Path.Combine( "cache", "ugc" ) ); } catch ( IOException ex ) { Log.WriteError( "UGCHandler", "Unable to create ugc cache directory: {0}", ex.Message ); } manager.Subscribe<SteamUnifiedMessages.ServiceMethodResponse>( OnServiceMethod ); Steam.Instance.CallbackManager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn ); }
public SteamNerd() { SteamClient = new SteamClient(); CallbackManager = new CallbackManager(SteamClient); ModuleManager = new ModuleManager(this); UserManager = new UserManager(this, "admins.txt"); ChatRoomManager = new ChatRoomManager(this, "chats.txt"); SteamUser = SteamClient.GetHandler<SteamUser>(); SteamFriends = SteamClient.GetHandler<SteamFriends>(); SubscribeCallbacks(); _login = new Login(this, CallbackManager); }
public Connection(CallbackManager manager) : base(manager) { SentryFile = Path.Combine(Application.Path, "files", ".support", "sentry.bin"); ReconnectionTimer = new Timer(); ReconnectionTimer.AutoReset = false; ReconnectionTimer.Elapsed += Reconnect; ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds; manager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected)); manager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected)); manager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn)); manager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff)); manager.Register(new Callback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth)); }
public SteamManager( CallbackManager manager ) { handlers = new List<SteamHandler>(); var handlerTypes = Assembly.GetExecutingAssembly().GetTypes() .Where( t => t.IsSubclassOf( typeof( SteamHandler ) ) ); foreach ( var type in handlerTypes ) { var handler = Activator.CreateInstance( type, manager ) as SteamHandler; Log.WriteDebug( "SteamManager", "Registering handler {0}", type ); handlers.Add( handler ); } }
public void OnGetPayloadComplete(ResultContainer resultContainer) { var result = new PayloadResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public void OnRefreshCurrentAccessTokenComplete(ResultContainer resultContainer) { var result = new AccessTokenRefreshResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public EditorFacebook(IEditorWrapper wrapper, CallbackManager callbackManager) : base(callbackManager) { this.editorWrapper = wrapper; }
public void OnUploadVideoToMediaLibraryComplete(ResultContainer resultContainer) { var result = new MediaUploadResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public void OnGetCatalogComplete(ResultContainer resultContainer) { var result = new CatalogResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public void OnGetPurchasesComplete(ResultContainer resultContainer) { var result = new PurchasesResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public CanvasFacebook(ICanvasJSWrapper canvasJSWrapper, CallbackManager callbackManager) : base(callbackManager) { this.canvasJSWrapper = canvasJSWrapper; }
public AndroidFacebook(IAndroidWrapper androidWrapper, CallbackManager callbackManager) : base(callbackManager) { this.KeyHash = string.Empty; this.androidWrapper = androidWrapper; }
void editor_ControlsCreated(object sender, EventArgs e) { var editor = (ASPxGridListEditor)sender; editor.ControlsCreated -= editor_ControlsCreated; editor.Grid.ClientSideEvents.Init = string.Format( CultureInfo.InvariantCulture, "function(s,e) {{s.selectedRowCount = s.GetSelectedKeysOnPage().length; s.SelectionChanged.AddHandler(function() {{if (s.selectedRowCount != s.GetSelectedKeysOnPage().length) {{s.selectedRowCount = s.GetSelectedKeysOnPage().length; {0} }}; s.firstSelectionChangedAfterInit = false;}}); }}", CallbackManager.GetScript(GetType().Name, "'RefreshCallback'")); }
public WebAuth(CallbackManager manager) : base(manager) { manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe <SteamUser.WebAPIUserNonceCallback>(OnWebAPIUserNonce); }
public AndroidFacebook(IAndroidJavaClass facebookJavaClass, CallbackManager callbackManager) : base(callbackManager) { this.KeyHash = string.Empty; this.facebookJava = facebookJavaClass; }
public Steam3Session(SteamUser.LogOnDetails details) { this.logonDetails = details; this.authenticatedUser = details.Username != null; this.credentials = new Credentials(); this.bConnected = false; this.bConnecting = false; this.bAborted = false; this.bExpectingDisconnectRemote = false; this.bDidDisconnect = false; this.bDidReceiveLoginKey = false; this.seq = 0; this.AppTickets = new Dictionary <uint, byte[]>(); this.AppTokens = new Dictionary <uint, ulong>(); this.PackageTokens = new Dictionary <uint, ulong>(); this.DepotKeys = new Dictionary <uint, byte[]>(); this.CDNAuthTokens = new ConcurrentDictionary <string, TaskCompletionSource <SteamApps.CDNAuthTokenCallback> >(); this.AppInfo = new Dictionary <uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>(); this.PackageInfo = new Dictionary <uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>(); this.AppBetaPasswords = new Dictionary <string, byte[]>(); this.steamClient = new SteamClient(); this.steamUser = this.steamClient.GetHandler <SteamUser>(); this.steamApps = this.steamClient.GetHandler <SteamApps>(); var steamUnifiedMessages = this.steamClient.GetHandler <SteamUnifiedMessages>(); this.steamPublishedFile = steamUnifiedMessages.CreateService <IPublishedFile>(); this.callbacks = new CallbackManager(this.steamClient); this.callbacks.Subscribe <SteamClient.ConnectedCallback>(ConnectedCallback); this.callbacks.Subscribe <SteamClient.DisconnectedCallback>(DisconnectedCallback); this.callbacks.Subscribe <SteamUser.LoggedOnCallback>(LogOnCallback); this.callbacks.Subscribe <SteamUser.SessionTokenCallback>(SessionTokenCallback); this.callbacks.Subscribe <SteamApps.LicenseListCallback>(LicenseListCallback); this.callbacks.Subscribe <SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback); this.callbacks.Subscribe <SteamUser.LoginKeyCallback>(LoginKeyCallback); Console.Write("Connecting to Steam3..."); if (authenticatedUser) { FileInfo fi = new FileInfo(String.Format("{0}.sentryFile", logonDetails.Username)); if (AccountSettingsStore.Instance.SentryData != null && AccountSettingsStore.Instance.SentryData.ContainsKey(logonDetails.Username)) { logonDetails.SentryFileHash = Util.SHAHash(AccountSettingsStore.Instance.SentryData[logonDetails.Username]); } else if (fi.Exists && fi.Length > 0) { var sentryData = File.ReadAllBytes(fi.FullName); logonDetails.SentryFileHash = Util.SHAHash(sentryData); AccountSettingsStore.Instance.SentryData[logonDetails.Username] = sentryData; AccountSettingsStore.Save(); } } Connect(); }
public CallbackManagerFacts_LegacyBehavior() { client = new SteamClient(); mgr = new CallbackManager(client); }
public void OnShowInterstitialAdComplete(ResultContainer resultContainer) { var result = new InterstitialAdResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public void OnConsumePurchaseComplete(ResultContainer resultContainer) { var result = new ConsumePurchaseResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public void OnScheduleAppToUserNotificationComplete(ResultContainer resultContainer) { var result = new ScheduleAppToUserNotificationResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public PlayerCountHandler(CallbackManager manager) : base(manager) { }
public void OnFetchDeferredAppLinkComplete(ResultContainer resultContainer) { var result = new AppLinkResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public void OnOnIAPReadyComplete(ResultContainer resultContainer) { var result = new IAPReadyResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public void OnAppInviteComplete(string message) { var result = new AppInviteResult(message); CallbackManager.OnFacebookResponse(result); }
public void OnFetchDeferredAppLinkComplete(string message) { var result = new AppLinkResult(message); CallbackManager.OnFacebookResponse(result); }
public void OnInitCloudGameComplete(ResultContainer resultContainer) { var result = new InitCloudGameResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public void OnFriendFinderComplete(ResultContainer resultContainer) { var result = new GamingServicesFriendFinderResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public override void OnAppRequestsComplete(ResultContainer resultContainer) { var result = new AppRequestResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public override void OnAppRequestsComplete(string message) { var result = new AppRequestResult(message); CallbackManager.OnFacebookResponse(result); }
public void OnShowRewardedVideoComplete(ResultContainer resultContainer) { var result = new RewardedVideoResult(resultContainer); CallbackManager.OnFacebookResponse(result); }
public override void OnGroupJoinComplete(string message) { var result = new GroupJoinResult(message); CallbackManager.OnFacebookResponse(result); }
public override void OnShareLinkComplete(string message) { var result = new ShareResult(message); CallbackManager.OnFacebookResponse(result); }
public AndroidFacebook(IAndroidJavaClass fbJavaClass, CallbackManager callbackManager) : base(callbackManager) { this.KeyHash = ""; this.fbJava = fbJavaClass; }
public override void OnShareLinkComplete(ResultContainer resultContainer) { var result = new ShareResult(resultContainer); CallbackManager.OnFacebookResponse(result); }