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)
{
}
