internal void HandleSetResult(SharkResponseMessage p_Message) { if (m_Created) { return; } var s_Message = p_Message.As <SuccessResponse <String> >(); if (s_Message == null) { return; } if (s_Message.Success == null || s_Message.Success != "set") { return; } Library.Chat.PublishToChannels(new List <string>() { Channel }, new Dictionary <String, String>() { { "setup", ControlChannel } }); }
private void HandleSubscribeToMetaUsers(SharkResponseMessage p_Message) { var s_Message = p_Message.As <SubscribeToMetaUsersResponse>(); var s_OnlineUsers = new List <Int64>(); foreach (var s_User in s_Message.Success) { if (s_User.Status == "logged_in") { s_OnlineUsers.Add(Int64.Parse(s_User.UserID)); } } if (m_PendingOnlineUsers == null) { m_PendingOnlineUsers = new List <long>(); } m_PendingOnlineUsers.AddRange(s_OnlineUsers); if (s_Message.Blackbox.ContainsKey("partID") && s_Message.Blackbox.ContainsKey("partsTotal") && (int)s_Message.Blackbox["partID"] >= (int)s_Message.Blackbox["partsTotal"]) { //FetchUsersStatus(m_PendingOnlineUsers, true, s_Message.Blackbox.Initial); m_PendingOnlineUsers.Clear(); } if (s_OnlineUsers.Count > 0) { FetchUsersStatuses(m_PendingOnlineUsers, true, s_Message.Blackbox.ContainsKey("initial") && (bool)s_Message.Blackbox["initial"]); } }
private void HandleSet(SharkResponseMessage p_Message) { var s_BasicResponse = p_Message.As <BasicResponse>(); var s_SuccessResponse = p_Message.As <SuccessResponse <String> >(); switch (s_BasicResponse.Type) { case "error": { Trace.WriteLine(String.Format("Set failed. Error: {0}", p_Message.As <ErrorResponse>().Error)); break; } case "success": { break; } default: { Trace.WriteLine("Unknown set response type received!"); break; } } DispatchEvent((int)ChatEvent.SetResult, new SetResultEvent() { Success = s_BasicResponse.Type == "success" && s_SuccessResponse != null && s_SuccessResponse.Success != null, Result = p_Message, Blackbox = s_SuccessResponse != null ? s_SuccessResponse.Blackbox : null }); }
private void OnMessageProcessed(object p_Sender, SharkResponseMessage p_Message) { Action <SharkResponseMessage> s_Handler; if (!m_Handlers.TryGetValue(p_Message.Command, out s_Handler)) { Trace.WriteLine(String.Format("Received an unhandled command: {0}", p_Message.Command)); return; } //Trace.WriteLine(String.Format("Received a known command: {0}", p_Message.Command)); s_Handler(p_Message); }
private bool HandlePushSubinfoChange(SharkResponseMessage p_Message) { var s_Message = p_Message.As <SubinfoChangeResponse>(); if (s_Message.SubinfoChange == null) { return(false); } DispatchEvent((int)ChatEvent.SubUpdate, new SubUpdateEvent() { Type = "properties", Sub = s_Message.SubinfoChange.Sub, Params = s_Message.SubinfoChange.Params }); return(true); }
private void HandlePush(SharkResponseMessage p_Message) { var s_BasicResponse = p_Message.As <BasicResponse>(); if (s_BasicResponse.Type == "logged_in" && HandlePushLoggedIn(p_Message)) { return; } if (s_BasicResponse.Type == "logged_out" && HandlePushLoggedOut(p_Message)) { return; } if (s_BasicResponse.Type == "key_change" && HandlePushKeyChange(p_Message)) { return; } if (s_BasicResponse.Type == "subinfo_change" && HandlePushSubinfoChange(p_Message)) { return; } if (s_BasicResponse.Type == "publish" && HandlePushPublish(p_Message)) { return; } if (s_BasicResponse.Type == "sub_alert" && HandlePushSubAlert(p_Message)) { return; } if (s_BasicResponse.Type == "unsub_alert" && HandlePushUnsubAlert(p_Message)) { return; } if (s_BasicResponse.Type == "sub_rename" && HandlePushSubRename(p_Message)) { return; } }
private bool HandlePushUnsubAlert(SharkResponseMessage p_Message) { var s_Message = p_Message.As <UnsubAlertResponse>(); JToken s_Sub; if (!s_Message.UnsubAlert.TryGetValue("sub", out s_Sub)) { return(true); } if (Library.Broadcast.ActiveBroadcastID == null || s_Sub.Value <String>() != GetChatChannel(Library.Broadcast.ActiveBroadcastID)) { return(true); } JToken s_IDToken; if (!s_Message.UnsubAlert.TryGetValue("id", out s_IDToken)) { return(true); } var s_ID = s_IDToken.ToObject <Dictionary <String, JToken> >(); if (!s_ID.ContainsKey("app_data") || !s_ID.ContainsKey("userid") || s_ID["userid"].Type != JTokenType.Integer) { return(true); } var s_UserData = s_ID["app_data"].ToObject <ChatUserData>(); var s_UserID = Int64.Parse(s_ID["userid"].Value <String>()); Library.DispatchEvent(ClientEvent.UserLeftBroadcast, new UserLeftBroadcastEvent() { UserID = s_UserID, UserData = s_UserData }); return(true); }
private bool HandlePushKeyChange(SharkResponseMessage p_Message) { var s_Message = p_Message.As <KeyChangeResponse>(); if (s_Message.KeyChange == null || s_Message.KeyChange.KeyVals == null) { return(false); } if (!String.IsNullOrWhiteSpace(s_Message.KeyChange.UserID)) { // TODO: Implement. return(true); } if (!String.IsNullOrWhiteSpace(s_Message.KeyChange.ArtistID)) { // TODO: Implement. return(true); } if (!String.IsNullOrWhiteSpace(s_Message.KeyChange.Sub)) { var s_MetaSubChanges = s_Message.KeyChange.KeyVals.Where(p_KeyVal => p_KeyVal != null) .ToDictionary(p_KeyVal => p_KeyVal.Key, p_KeyVal => p_KeyVal.Value); DispatchEvent((int)ChatEvent.SubUpdate, new SubUpdateEvent() { Type = "properties", Sub = s_Message.KeyChange.Sub, Params = s_MetaSubChanges }); return(true); } return(true); }
private void HandleMetaSub(SharkResponseMessage p_Message) { switch (p_Message.As <BasicResponse>().Type) { case "error": { Trace.WriteLine(String.Format("Set failed. Error: {0}", p_Message.As <ErrorResponse>().Error)); // TODO: Retry request if we have enough data. break; } case "success": { var s_Message = p_Message.As <SuccessResponse <JToken> >(); if (s_Message.Blackbox != null) { if (s_Message.Blackbox.ContainsKey("source") && s_Message.Blackbox["source"].Value <String>() == "subscribeToMetaUsers") { HandleSubscribeToMetaUsers(p_Message); break; } } Trace.WriteLine("Unknown metasub response type received!"); break; } default: { Trace.WriteLine("Unknown metasub response type received!"); break; } } }
private void OnMessageProcessedInternal(object p_Sender, SharkResponseMessage p_SharkResponseMessage) { Trace.WriteLine("Received Message:"); Trace.WriteLine("[S -> C] " + p_SharkResponseMessage); Trace.WriteLine(""); if (p_SharkResponseMessage.Blackbox == null || !p_SharkResponseMessage.Blackbox.ContainsKey("__gspid")) { if (OnMessageProcessed != null) { OnMessageProcessed(this, p_SharkResponseMessage); } return; } var s_PacketID = p_SharkResponseMessage.Blackbox["__gspid"].Value <UInt16>(); Action <SharkResponseMessage> s_Callback; lock (m_PacketCallbacks) { if (!m_PacketCallbacks.ContainsKey(s_PacketID)) { if (OnMessageProcessed != null) { OnMessageProcessed(this, p_SharkResponseMessage); } return; } s_Callback = m_PacketCallbacks[s_PacketID]; m_PacketCallbacks.Remove(s_PacketID); } s_Callback(p_SharkResponseMessage); }
private bool HandlePushSubRename(SharkResponseMessage p_Message) { var s_Message = p_Message.As <SubRenameResponse>(); if (m_CurrentChannels.ContainsKey(s_Message.SubRename.OldName)) { if (m_CurrentChannels.ContainsKey(s_Message.SubRename.NewName)) { m_CurrentChannels[s_Message.SubRename.NewName] = m_CurrentChannels[s_Message.SubRename.OldName]; } else { m_CurrentChannels.Add(s_Message.SubRename.NewName, m_CurrentChannels[s_Message.SubRename.OldName]); } if (m_CurrentChannels[s_Message.SubRename.NewName].ContainsKey("sub")) { m_CurrentChannels[s_Message.SubRename.NewName]["sub"] = s_Message.SubRename.NewName; } else { m_CurrentChannels[s_Message.SubRename.NewName].Add("sub", s_Message.SubRename.NewName); } m_CurrentChannels.Remove(s_Message.SubRename.OldName); } DispatchEvent((int)ChatEvent.SubUpdate, new SubUpdateEvent() { Type = "rename", Sub = s_Message.SubRename.OldName, NewName = s_Message.SubRename.NewName }); return(true); }
private void HandleSub(SharkResponseMessage p_Message) { switch (p_Message.As <BasicResponse>().Type) { case "error": { Trace.WriteLine(String.Format("Sub failed. Error: {0}", p_Message.As <ErrorResponse>().Error)); break; } case "success": { var s_Message = p_Message.As <SubscriptionResponse>(); HandleSub(s_Message.Success, s_Message.Blackbox); break; } default: { Trace.WriteLine("Unknown sub response type received!"); break; } } }
private void OnRestoreFinished(SharkResponseMessage p_SharkResponseMessage) { // Restore has finished. // We should now be fully authenticated. Library.DispatchEvent(ClientEvent.Authenticated, null); }
private void HandleIdentify(SharkResponseMessage p_Message) { switch (p_Message.As <BasicResponse>().Type) { case "error": { Trace.WriteLine(String.Format("Failed to identify with the Chat Service. Error: {0}", p_Message.As <ErrorResponse>().Error)); Library.DispatchEvent(ClientEvent.AuthenticationFailed, new AuthenticationFailureEvent() { Error = p_Message.As <ErrorResponse>().Error }); break; } case "success": { Trace.WriteLine("Successfully authenticated with the Chat Service."); var s_Message = p_Message.As <IdentifyResponse>(); UID = s_Message.Success.ID.UID; UpdateUserData(); var s_ChannelsToJoin = new List <Object>(); var s_GlobalChannel = new Dictionary <String, Object> { { "sub", "global" }, { "overwrite_params", false }, { "create_when_dne", true }, { "try_to_own", false } }; s_ChannelsToJoin.Add(s_GlobalChannel); var s_FollowingUsers = Library.User.GetFollowingUsers().Select(p_User => p_User.UserID).ToList(); SubscribeToMetaUsers(s_FollowingUsers, false, true); // TODO: Verify Artist support works var s_FollowingArtists = Library.User.GetFollowingArtists().Select(p_User => p_User.UserID).ToList(); SubscribeToMetaArtists(s_FollowingArtists, false, true); if (Library.User.Data != null && Library.User.Data.ArtistID != 0) { s_ChannelsToJoin.Add("artist:" + Library.User.Data.ArtistID); } else if (Library.User.Data != null && Library.User.Data.UserID != 0) { s_ChannelsToJoin.Add("user:"******"newUser", true } }); SendRestoreLookup(); SetSubscriptionParameters("user:"******"unsub_alert", true }, { "sub_alert", true }, { "owners", new List <Dictionary <String, String> >() { new Dictionary <string, string>() { { "type", "userid" }, { "name", Library.User.Data.UserID.ToString() } } } } }); // TODO: Do we really need to do this? Library.User.StoreChatIdentity(); // CHAT_READY BroadcastMessageToSelf("statusRequest"); break; } default: { Trace.WriteLine("Unknown response type received!"); break; } } }
private bool HandlePushPublish(SharkResponseMessage p_Message) { var s_Message = p_Message.As <PublishResponse>(); if (s_Message.Publish == null) { return(false); } if (Library.User.Data != null && Library.User.Data.ArtistID > 0 && s_Message.Publish.Destination == "artist:" + Library.User.Data.ArtistID && s_Message.Publish.ID != null && ((s_Message.Publish.ID.ContainsKey("artistid") && s_Message.Publish.ID["artistid"].Value <String>() != "False" && Int64.Parse(s_Message.Publish.ID["artistid"].Value <String>() ?? "0") == Library.User.Data.ArtistID) || (s_Message.Publish.ID.ContainsKey("sudo") && (bool)s_Message.Publish.ID["sudo"]))) { HandleSelfMessages(s_Message); } else if (Library.User.Data != null && Library.User.Data.UserID > 0 && s_Message.Publish.Destination == "user:"******"userid") && s_Message.Publish.ID["userid"].Value <String>() != "False" && Int64.Parse(s_Message.Publish.ID["userid"].Value <String>() ?? "0") == Library.User.Data.UserID) || (s_Message.Publish.ID.ContainsKey("sudo") && (bool)s_Message.Publish.ID["sudo"]))) { HandleSelfMessages(s_Message); } // Is this a chat message? var s_Value = s_Message.Publish.Value; if (s_Value.ContainsKey("type") && s_Value["type"].Value <String>() == "chat") { var s_ID = s_Message.Publish.ID ?? new Dictionary <string, JToken>(); var s_ChatMessage = s_Value["data"].Value <String>(); var s_UserID = s_ID.ContainsKey("userid") ? Int64.Parse(s_ID["userid"].Value <String>() ?? "0") : 0; var s_UserAppData = s_ID.ContainsKey("app_data") ? s_ID["app_data"] : null; String s_UserName = null; if (s_UserAppData != null) { s_UserName = s_UserAppData["n"].Value <String>(); } Library.DispatchEvent(ClientEvent.ChatMessage, new ChatMessageEvent() { DestinationChannel = s_Message.Publish.Destination, UserID = s_UserID, UserName = s_UserName, ChatMessage = s_ChatMessage }); } DispatchEvent((int)ChatEvent.SubUpdate, new SubUpdateEvent() { Type = "publish", Sub = s_Message.Publish.Destination, ID = s_Message.Publish.ID, Value = s_Message.Publish.Value }); return(true); }
private void OnBroadcastSubscriptionData(SharkResponseMessage p_SharkResponseMessage) { var s_Response = p_SharkResponseMessage.As <ReturnResponse>(); if (s_Response == null || s_Response.Return == null || s_Response.Return["values"] == null) { // Proceed with channel creation. Library.Remora.JoinControlChannels(); return; } var s_Values = s_Response.Return["values"].ToObject <JArray>(); if (s_Values.Count != 11) { // Proceed with channel creation. Library.Remora.JoinControlChannels(); return; } if (s_Values[10].Type != JTokenType.String) { // Proceed with channel creation. Library.Remora.JoinControlChannels(); return; } var s_LastQueueID = s_Values[10].Value <String>(); if (String.IsNullOrWhiteSpace(s_LastQueueID)) { // Proceed with channel creation. Library.Remora.JoinControlChannels(); return; } // Set currently playing song data. var s_BroadcastData = s_Values[0].ToObject <Dictionary <String, JToken> >(); // Broadcast has ended; queue doesn't exist anymore. if (s_BroadcastData.ContainsKey("ended") && s_BroadcastData["ended"].Value <bool>()) { Library.Remora.JoinControlChannels(); return; } if (s_BroadcastData.ContainsKey("active")) { var s_SongData = s_BroadcastData["active"].ToObject <PlaybackStatusData.ActiveBroadcastData>(); if (s_SongData != null && s_SongData.Data != null) { PlayingSongID = s_SongData.Data.SongID; PlayingSongName = s_SongData.Data.SongName; PlayingSongArtist = s_SongData.Data.ArtistName; PlayingArtistID = s_SongData.Data.ArtistID; PlayingSongAlbum = s_SongData.Data.AlbumName; PlayingAlbumID = s_SongData.Data.AlbumID; PlayingSongQueueID = s_SongData.QueueSongID; } else { PlayingSongID = PlayingSongQueueID = PlayingArtistID = PlayingAlbumID = 0; PlayingSongName = PlayingSongAlbum = PlayingSongArtist = null; } } else { PlayingSongID = PlayingSongQueueID = PlayingArtistID = PlayingAlbumID = 0; PlayingSongName = PlayingSongAlbum = PlayingSongArtist = null; } // Attempt to resume the queue. Library.Remora.ResumeQueue(s_LastQueueID); }
private void HandlePub(SharkResponseMessage p_Message) { var s_BasicResponse = p_Message.As <BasicResponse>(); var s_ReturnResponse = p_Message.As <ReturnResponse>(); var s_ErrorResponse = p_Message.As <ErrorResponse>(); if (s_BasicResponse.Type == "return" && s_ReturnResponse != null && s_ReturnResponse.Return != null && s_ReturnResponse.Return.Type == JTokenType.Array && s_ReturnResponse.Return.ToObject <JArray>().Count > 0) { var s_ReturnValue = s_ReturnResponse.Return.ToObject <JArray>()[0].ToObject <Dictionary <String, Object> >(); if (Library.User.Data != null && s_ReturnValue.ContainsKey("name") && ((Library.User.Data.ArtistID > 0 && s_ReturnValue["name"] as String == "artist:" + Library.User.Data.ArtistID) || Library.User.Data.UserID > 0 && s_ReturnValue["name"] as String == "user:"******"error")) { DispatchEvent((int)ChatEvent.ChatError, new ChatErrorEvent { Error = s_ReturnValue["error"] as String, Source = s_ReturnResponse.Blackbox != null ? (s_ReturnResponse.Blackbox.ContainsKey("source") ? s_ReturnResponse.Blackbox["source"].Value <String>() : "") : "", Sub = s_ReturnValue.ContainsKey("name") ? s_ReturnValue["name"] as String : "", Command = "Pub" }); } DispatchEvent((int)ChatEvent.PubResult, new PubResultEvent() { Success = !s_ReturnValue.ContainsKey("error"), Result = s_ReturnValue, Sub = s_ReturnValue.ContainsKey("name") ? s_ReturnValue["name"] as String : "", Blackbox = s_ReturnResponse.Blackbox }); } else if (s_BasicResponse.Type == "error" && s_ErrorResponse != null) { DispatchEvent((int)ChatEvent.ChatError, new ChatErrorEvent { Error = s_ErrorResponse.Error, Source = s_ReturnResponse.Blackbox != null ? (s_ReturnResponse.Blackbox.ContainsKey("source") ? s_ReturnResponse.Blackbox["source"].Value <String>() : "") : "", Command = "Pub" }); DispatchEvent((int)ChatEvent.PubResult, new PubResultEvent() { Success = false, Result = p_Message, Blackbox = s_ReturnResponse.Blackbox }); } }
private bool HandlePushLoggedOut(SharkResponseMessage p_Message) { // TODO: Implement. return(true); }
private void HandleGet(SharkResponseMessage p_Message) { }