void HandleSteamCallback(CallbackMsg msg) { var messageMap = new Dictionary <Type, Action <CallbackMsg> > { { typeof(SteamClient.ConnectedCallback), HandleConnected }, { typeof(SteamClient.DisconnectedCallback), HandleDisconnected }, { typeof(SteamUser.LoggedOnCallback), HandleLoggedOn }, { typeof(SteamUser.LoggedOffCallback), HandleLoggedOff }, { typeof(SteamUser.LoginKeyCallback), HandleLoginKey }, { typeof(SteamWeb.WebLoggedOnCallback), HandleWebLoggedOn }, { typeof(SteamFriends.FriendMsgCallback), HandleFriendMessage }, { typeof(SteamFriends.FriendAddedCallback), HandleFriendAdded }, { typeof(SteamTrading.TradeRequestCallback), HandleTradeRequest }, { typeof(SteamTrading.TradeProposedCallback), HandleTradeProposed }, { typeof(SteamGameCoordinator.MessageCallback), HandleGCMessage }, }; Action <CallbackMsg> func; if (!messageMap.TryGetValue(msg.GetType(), out func)) { return; } func(msg); }
/// <summary> /// Pushes a callback to registered handlers /// </summary> /// <param name="msg">The callback to push</param> private void Push(CallbackMsg msg) { for (int i = 0; i < callbackHandlers.Count; i++) { callbackHandlers[i].HandleCallback(msg); } }
void HandleDisconnected(CallbackMsg msg) { var details = msg as SteamClient.DisconnectedCallback; Logger.WriteLine("Disconnected from the Steam network."); IsRunning = false; }
public static void Update() { CallbackMsg msg = SteamClient.GetCallback(); if (msg == null) { return; } SteamClient.FreeLastCallback(); if (msg.IsType <SteamClient.ConnectedCallback>()) { SteamUser.LogOn(new SteamUser.LogOnDetails() { Username = Steam3.UserName, Password = Steam3.Password, AuthCode = Steam3.AuthCode, }); } List <ICallbackHandler> tempHandlers = new List <ICallbackHandler>(callbackHandlers); // push it along to anyone who wants to handle this foreach (ICallbackHandler handler in tempHandlers) { handler.HandleCallback(msg); } }
public void HandleCallback(CallbackMsg msg) { if (!msg.IsType <SteamFriends.FriendMsgCallback>()) { return; } msg.Handle <SteamFriends.FriendMsgCallback>(friendMsg => { EChatEntryType type = friendMsg.EntryType; if (type == EChatEntryType.ChatMsg || type == EChatEntryType.Emote || type == EChatEntryType.InviteGame) { ChatDialog cd = GetChat(friendMsg.Sender); cd.HandleChat(friendMsg); } }); msg.Handle <SteamFriends.PersonaStateCallback>(personaState => { if (personaState.FriendID == Steam3.SteamClient.SteamID) { return; } ChatDialog cd = GetChat(personaState.FriendID); cd.HandleState(personaState); }); }
public static void Update() { CallbackMsg Message = Client.GetCallback(); if (Message == null) { return; } Client.FreeLastCallback(); if (Message.IsType <SteamClient.ConnectedCallback>()) { Console.WriteLine("Steam >> Logging in."); User.LogOn(new SteamUser.LogOnDetails() { Username = Username, Password = Password, AuthCode = AuthCode }); } List <ICallbackHandler> Handlers = new List <ICallbackHandler>(Callbacks); foreach (ICallbackHandler i in Handlers) { i.HandleCallback(Message); } }
void HandleLoggedOff(CallbackMsg msg) { var details = msg as SteamUser.LoggedOffCallback; Logger.WriteLine("Logged off Steam network: " + details.Result); IsRunning = false; }
public void HandleCallback(CallbackMsg msg) { if (msg.IsType <SteamUser.LoginKeyCallback>()) { HandleLogin((SteamUser.LoginKeyCallback)msg); } if (msg.IsType <SteamUser.LoggedOffCallback>()) { HandleLogoff((SteamUser.LoggedOffCallback)msg); } if (msg.IsType <SteamFriends.ChatEnterCallback>()) { HandleChatEnter((SteamFriends.ChatEnterCallback)msg); } if (msg.IsType <SteamFriends.ChatMsgCallback>()) { HandleChatMessage((SteamFriends.ChatMsgCallback)msg); } if (msg.IsType <SteamFriends.PersonaStateCallback>()) { HandlePersonaStateChange((SteamFriends.PersonaStateCallback)msg); } if (msg.IsType <SteamFriends.ChatMemberInfoCallback>()) { HandleChatMemberInfoCallback((SteamFriends.ChatMemberInfoCallback)msg); } if (msg.IsType <SteamFriends.ChatActionResultCallback>()) { HandleChatActionResultCallback((SteamFriends.ChatActionResultCallback)msg); } }
static void Main(string[] args) { sclient.Connect(); CallbackMsg msg = sclient.GetCallback(); Type a = msg.GetType(); msg = sclient.GetCallback(); msg.ToString(); var asdf = (SteamUser.LoggedOnCallback)msg; if (asdf.Result == EResult.AccountLogonDenied) { Console.Write("Please enter the steam access code here: "); string steamaccesscode = Console.ReadLine(); sUser.LogOn(new SteamUser.LogOnDetails() { Username = username, Password = password, AuthCode = steamaccesscode }); msg = sclient.GetCallback(); asdf = (SteamUser.LoggedOnCallback)msg; } if (asdf.Result == EResult.OK) { sFriends.SendChatMessage(new SteamID("STEAM_0:1:16516144"), EChatEntryType.ChatMsg, "Fennecs :D"); Console.WriteLine(); Console.WriteLine("Logged in succesfully. Press any key to exit"); sclient.Disconnect(); } }
void HandleGCMessage(CallbackMsg msg) { var details = msg as SteamGameCoordinator.MessageCallback; var emsg = GetEMsgDisplayString(details.EMsg); var messageMap = new Dictionary <uint, Action <IPacketGCMsg> > { { EGCMsg.ClientWelcome, OnGCClientWelcome }, // SO messages { EGCMsg.SOCacheSubscriptionCheck, OnGCSOCacheSubscriptionCheck }, { EGCMsg.SOCacheSubscribed, OnGCSOCacheSubscribed }, { EGCMsg.SOCreate, OnGCSOCreate }, { EGCMsg.SODestroy, OnGCSODestroy }, //{ EGCMsg.SOUpdate, OnGCSOUpdate }, { EGCMsg.UpdateItemSchema, OnGCUpdateItemSchema }, { EGCMsg.CraftResponse, OnGCCraftResponse }, }; Action <IPacketGCMsg> func; if (!messageMap.TryGetValue(details.EMsg, out func)) { Logger.WriteLine("Unhandled GC message: " + emsg); return; } func(details.Message); }
/// <summary> /// Pushes a callback to registered handlers /// </summary> /// <param name="msg">The callback to push</param> private void Push(CallbackMsg msg) { foreach (ICallbackHandler handler in callbackHandlers) { handler.HandleCallback(msg); } }
public void pollSteam() { while (true) { CallbackMsg msg = SteamClient.WaitForCallback(true); HandleSteamMessage(msg); } }
public void HandleCallback(CallbackMsg msg) { if (msg.IsType <SteamFriends.PersonaStateCallback>()) { SteamFriends.PersonaStateCallback callback = (SteamFriends.PersonaStateCallback)msg; LoadFriendsList(); } }
private void BackgroundWorkerOnDoWork(object sender, DoWorkEventArgs doWorkEventArgs) { while (!backgroundWorker.CancellationPending) { CallbackMsg msg = SteamClient.WaitForCallback(true); HandleSteamMessage(msg); } }
void HandleTradeProposed(CallbackMsg msg) { var details = msg as SteamTrading.TradeProposedCallback; string name = SteamFriends.GetFriendPersonaName(details.Other); string log = String.Format("{0} is trying to start a trade...", name); Logger.WriteLine(log); }
void HandleLoginKey(CallbackMsg msg) { var details = msg as SteamUser.LoginKeyCallback; //Logger.WriteLine("Login Key: " + details.LoginKey); Logger.WriteLine("Logging to the Steam Web network..."); SteamWeb.LogOn(details); }
void HandleLoggedOn(CallbackMsg msg) { var details = msg as SteamUser.LoggedOnCallback; Logger.WriteLine("Logged on: " + details.Result); Logger.WriteLine("Launching TF2..."); ConnectToGC(TF2App); }
public void HandleCallback(CallbackMsg msg) { if (msg.IsType <SteamUser.LoginKeyCallback>()) { GetClient().Friends.SetPersonaState(EPersonaState.Online); Friend.Me = new Friend(GetClient().User.GetSteamID()); Friend.Me.Name = "me"; SteamAlerts.ShowToast("Connected to Steam"); } else if (msg.IsType <SteamUser.LogOnCallback>()) { SteamUser.LogOnCallback callback = (SteamUser.LogOnCallback)msg; if (callback.Result == EResult.OK) { EnableAutoReconnect(); } else { DisableAutoReconnect(); } } else if (msg.IsType <SteamFriends.FriendMsgCallback>()) { SteamFriends.FriendMsgCallback callback = (SteamFriends.FriendMsgCallback)msg; if (callback.EntryType == EChatEntryType.ChatMsg) { Friend friend = Friend.GetFriendBySteamId(callback.Sender.ToString()); if (friend != activeChat) { Intent intent = new Intent(SteamAlerts.GetContext(), typeof(Chat)); intent.SetAction("chat_notification_" + DateTime.Now.Ticks); intent.PutExtra("steam_id", friend.SteamId.ToString()); SteamAlerts.Notification("Message from " + friend.Name, friend.Name + ": " + callback.Message, callback.Message, intent, "steam_id", friend.SteamId.ToString()); SteamAlerts.PlaySound(); SteamAlerts.Vibrate(400); } } } else if (msg.IsType <SteamClient.ConnectCallback>()) { SteamAlerts.Notification("Steam Droid", "Connected to Steam", "Connected to Steam", new Intent(SteamAlerts.GetContext(), typeof(Main)), null, null); } else if (msg.IsType <SteamClient.DisconnectCallback>()) { SteamAlerts.Notification("Steam Droid", "Disconnected from Steam", "Connected to Steam", new Intent(SteamAlerts.GetContext(), typeof(Main)), null, null); SteamAlerts.ShowToast("Disconnected from Steam"); } }
/// <summary> /// Handles callbacks from steam. /// </summary> /// <param name='msg'> /// Message. /// </param> public void HandleCallback(CallbackMsg msg) { if (msg.IsType <SteamFriends.ChatMsgCallback>()) { SteamFriends.ChatMsgCallback callback = (SteamFriends.ChatMsgCallback)msg; if (callback.ChatMsgType == EChatEntryType.ChatMsg) { ChatMessage message = new ChatMessage(this, callback.Message); adapter.Add(message); } } }
/// <summary> /// Linked to <see cref="Client.GetCallback"/> /// </summary> /// <param name="pipe"></param> /// <param name="c"></param> /// <returns>Whether there is a new callback</returns> public bool GetCallback(IntPtr _, int pipe_id, ref CallbackMsg c) { var new_callback = Client.Client.GetCallback(pipe_id); if (new_callback == null) { return(false); } c = (CallbackMsg)new_callback; return(true); }
public void HandleCallback(CallbackMsg msg) { if (msg.IsType <SteamClient.ConnectCallback>()) { Logger.Get().Log("[Callback] Connected"); } else if (msg.IsType <SteamClient.DisconnectCallback>()) { Logger.Get().Log("[Callback] Disconnected"); IsAuthorized = false; Send(Protocol.Server.LoggedOut); } else if (msg.IsType <SteamUser.LogOnCallback>()) { SteamUser.LogOnCallback callback = (SteamUser.LogOnCallback)msg; Logger.Get().Log("[Callback] Logon: " + callback.Result + "/" + callback.ExtendedResult); if (callback.Result == EResult.AccountLogonDenied || callback.Result == EResult.InvalidLoginAuthCode) { Send(Protocol.Server.AuthRequest); IsAuthorized = true; } if (callback.Result == EResult.OK) { IsAuthorized = true; } } else if (msg.IsType <SteamUser.LoginKeyCallback>()) { Logger.Get().Log("[Callback] Logged in, setting persona state to online"); steam.Friends.SetPersonaState(SteamKit2.EPersonaState.Online); Send(Protocol.Server.LoggedIn); } else if (msg.IsType <SteamFriends.FriendMsgCallback>()) { SteamFriends.FriendMsgCallback chat = (SteamFriends.FriendMsgCallback)msg; if (chat.EntryType == EChatEntryType.ChatMsg) { Send(Protocol.Server.ChatReceived, chat.Sender.ToString(), chat.Message); } } else if (msg.IsType <SteamFriends.PersonaStateCallback>()) { SteamFriends.PersonaStateCallback friend = (SteamFriends.PersonaStateCallback)msg; Send(Protocol.Server.FriendStateChanged, friend.FriendID.ToString(), friend.State.ToString(), friend.GameName); } }
public void HandleCallback(CallbackMsg msg) { if (msg.IsType <SteamFriends.FriendMsgCallback>()) { SteamFriends.FriendMsgCallback callback = (SteamFriends.FriendMsgCallback)msg; if (callback.EntryType == EChatEntryType.ChatMsg && callback.Sender == friend.SteamId) { ChatMessage message = new ChatMessage(friend, callback.Message); Add(message); NotifyDataSetChanged(); } } }
void ProcessSteamEvents() { CallbackMsg msg = SteamClient.GetCallback(); SteamClient.FreeLastCallback(); while (msg != null) { HandleSteamCallback(msg); msg = SteamClient.GetCallback(); SteamClient.FreeLastCallback(); } }
void HandleWebLoggedOn(CallbackMsg msg) { var details = msg as SteamWeb.WebLoggedOnCallback; if (details.Result != EResult.OK) { Logger.WriteLine("Could not login to Web."); return; } Logger.WriteLine("Logged in to web successfully."); if (OnWebLoggedOn != null) { OnWebLoggedOn(this); } }
public Bot(Configuration.BotInfo config, string apiKey, UserHandlerCreator handlerCreator, Interface gui, bool debug = false) { while (Interface.loginClicked == false) { // Wait for user to login } logOnDetails = new SteamUser.LogOnDetails { Username = Interface.username, Password = Interface.password }; Admins = new ulong[1]; Admins[0] = 123456789; this.apiKey = apiKey; LogLevel = Log.LogLevel.Info; //log = new Log(config.LogFile, this.DisplayName, LogLevel); CreateHandler = handlerCreator; BotControlClass = config.BotControlClass; // Hacking around https ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate; ////log.Debug("Initializing Steam Bot..."); SteamClient = new SteamClient(); SteamTrade = SteamClient.GetHandler <SteamTrading>(); SteamUser = SteamClient.GetHandler <SteamUser>(); SteamFriends = SteamClient.GetHandler <SteamFriends>(); gui.UpdateLog("\r\nConnecting, please wait..."); ////log.Info("Connecting..."); SteamClient.Connect(); Thread CallbackThread = new Thread(() => // Callback Handling { while (true) { CallbackMsg msg = SteamClient.WaitForCallback(true); HandleSteamMessage(msg, gui); } }); CallbackThread.Start(); ////log.Success("Done Loading Bot!"); CallbackThread.Join(); }
static void HandleCallbacks() { while (handlestuff) { CallbackMsg msg = sclient.GetCallback(); if (msg == null) { return; } if (msg.IsType <SteamClient.ConnectedCallback>()) { sUser.LogOn(new SteamUser.LogOnDetails() { Username = username, Password = password }); } } }
/// <summary> /// Updates the Steam client and passes any pending callbacks /// </summary> public void Update() { while (true) { CallbackMsg msg = client.WaitForCallback(true); if (msg == null) { return; } client.FreeLastCallback(); if (msg.IsType <SteamClient.ConnectCallback>()) { user.LogOn(new SteamUser.LogOnDetails() { Username = username, Password = password, AuthCode = authcode }); } if (msg.IsType <SteamClient.DisconnectCallback>()) { loggedIn = false; } if (msg.IsType <SteamUser.LogOnCallback>()) { SteamUser.LogOnCallback callback = (SteamUser.LogOnCallback)msg; if (callback.Result == EResult.OK) { this.loggedIn = true; this.authcode = null; } Friends.SetPersonaState(EPersonaState.Online); } Push(msg); } }
public void HandleCallback(CallbackMsg msg) { if (msg.IsType <SteamFriends.PersonaStateCallback>()) { var perState = (SteamFriends.PersonaStateCallback)msg; if (this.Friend == null) { return; } if (perState.FriendID != this.Friend.SteamID) { return; } this.UpdateFriend(this.Friend); } }
void HandleFriendMessage(CallbackMsg msg) { var details = msg as SteamFriends.FriendMsgCallback; if (details.EntryType != EChatEntryType.ChatMsg) { return; } string name = SteamFriends.GetFriendPersonaName(details.Sender); string log = String.Format("{0} says: {1}", name, details.Message); Logger.WriteLine(log); HandleCommand(details.Message, details.Sender, (sender, entry, text) => { SteamFriends.SendChatMessage(sender, entry, text); }); }
void HandleTradeRequest(CallbackMsg msg) { var details = msg as SteamTrading.TradeRequestCallback; string name = SteamFriends.GetFriendPersonaName(details.Other); string log = String.Format("Trade request to {0} status: {1}", name, details.Status.ToString()); Logger.WriteLine(log); ResetPendingTrade(); if (details.Status != EEconTradeResponse.Accepted) { return; } CurrentTrade = details.Trade; CurrentTrade.Initialize(); }