internal static void CallCallback <T>(PubnubChannelCallbackKey callbackKey, SafeDictionary <PubnubChannelCallbackKey, object> channelCallbacks,
IJsonPluggableLibrary jsonPluggableLibrary, List <object> itemMessage)
{
PubnubChannelCallback <T> currentPubnubCallback = channelCallbacks[callbackKey] as PubnubChannelCallback <T>;
if (currentPubnubCallback != null && currentPubnubCallback.Callback != null)
{
GoToCallback <T>(itemMessage, currentPubnubCallback.Callback, jsonPluggableLibrary);
}
}
internal static void ProcessResponseCallbacks <T> (List <object> result, RequestState <T> asynchRequestState,
SafeDictionary <string, long> multiChannelSubscribe, string cipherKey,
SafeDictionary <PubnubChannelCallbackKey, object> channelCallbacks, IJsonPluggableLibrary jsonPluggableLibrary)
{
if (result != null && result.Count >= 1 && asynchRequestState.UserCallback != null)
{
Helpers.ResponseToConnectCallback <T> (result, asynchRequestState.RespType, asynchRequestState.Channels,
asynchRequestState.ConnectCallback, multiChannelSubscribe, channelCallbacks, jsonPluggableLibrary);
Helpers.ResponseToUserCallback <T> (result, asynchRequestState.RespType, asynchRequestState.Channels,
asynchRequestState.UserCallback, cipherKey, channelCallbacks, jsonPluggableLibrary);
}
}
internal static List <string> GetValidChannels <T>(ResponseType type, Action <PubnubClientError> errorCallback,
string[] rawChannels, SafeDictionary <string, long> multiChannelSubscribe, PubnubErrorFilter.Level errorLevel)
{
List <string> validChannels = new List <string>();
if (rawChannels.Length > 0)
{
for (int index = 0; index < rawChannels.Length; index++)
{
if (rawChannels[index].Trim().Length > 0)
{
string channelName = rawChannels[index].Trim();
if (type == ResponseType.PresenceUnsubscribe)
{
channelName = string.Format("{0}{1}", channelName, Utility.PresenceChannelSuffix);
}
if (!multiChannelSubscribe.ContainsKey(channelName))
{
string message = string.Format("{0}Channel Not Subscribed", (Utility.IsPresenceChannel(channelName)) ? "Presence " : "");
PubnubErrorCode errorType = (Utility.IsPresenceChannel(channelName)) ? PubnubErrorCode.NotPresenceSubscribed : PubnubErrorCode.NotSubscribed;
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, channel={1} unsubscribe response={2}", DateTime.Now.ToString(), channelName, message), LoggingMethod.LevelInfo);
#endif
PubnubCallbacks.CallErrorCallback <T>(message, null, channelName, errorType, PubnubErrorSeverity.Info, errorCallback, errorLevel);
}
else
{
validChannels.Add(channelName);
}
}
else
{
string message = "Invalid Channel Name For Unsubscribe";
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, channel={1} unsubscribe response={2}", DateTime.Now.ToString(), rawChannels[index], message), LoggingMethod.LevelInfo);
#endif
PubnubCallbacks.CallErrorCallback <T>(message, null, rawChannels[index].ToString(), PubnubErrorCode.InvalidChannel, PubnubErrorSeverity.Info, errorCallback, errorLevel);
}
}
}
return(validChannels);
}
internal static bool CheckChannelsInMultiChannelSubscribeRequest(string multiChannel,
SafeDictionary <string, long> multiChannelSubscribe, SafeDictionary <string, PubnubWebRequest> channelRequest)
{
if (!channelRequest.ContainsKey(multiChannel))
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, MultiChannelSubscribeRequest _channelRequest doesnt contain {1}", DateTime.Now.ToString(), multiChannel), LoggingMethod.LevelInfo);
#endif
string[] currentChannels = multiChannelSubscribe.Keys.ToArray <string>();
if (currentChannels != null && currentChannels.Length > 0)
{
#if (ENABLE_PUBNUB_LOGGING)
string currentSubChannels = string.Join(",", currentChannels);
LoggingMethod.WriteToLog(string.Format("DateTime {0}, using existing channels: {1}", DateTime.Now.ToString(), currentSubChannels), LoggingMethod.LevelInfo);
#endif
}
else
{
return(true);
}
}
return(false);
}
internal static void ResponseToConnectCallback <T> (List <object> result, ResponseType type, string[] channels,
Action <T> connectCallback, SafeDictionary <string, long> multiChannelSubscribe, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, IJsonPluggableLibrary jsonPluggableLibrary)
{
//Check callback exists and make sure previous timetoken = 0
if (channels != null && connectCallback != null &&
channels.Length > 0)
{
IEnumerable <string> newChannels = from channel in multiChannelSubscribe
where channel.Value == 0
select channel.Key;
foreach (string channel in newChannels)
{
switch (type)
{
case ResponseType.Subscribe:
var connectResult = Helpers.CreateJsonResponse("Connected", channel, jsonPluggableLibrary);
PubnubCallbacks.SendConnectCallback <T> (jsonPluggableLibrary, connectResult, channel, type, channelCallbacks);
break;
case ResponseType.Presence:
var connectResult2 = Helpers.CreateJsonResponse("Presence Connected",
channel.Replace(Utility.PresenceChannelSuffix, ""), jsonPluggableLibrary);
PubnubCallbacks.SendConnectCallback <T> (jsonPluggableLibrary, connectResult2, channel, type, channelCallbacks);
break;
default:
break;
}
}
}
}
internal static void ResponseToUserCallback <T> (List <object> result, ResponseType type, string[] channels,
Action <T> userCallback, string cipherKey, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, IJsonPluggableLibrary jsonPluggableLibrary)
{
switch (type)
{
case ResponseType.Subscribe:
case ResponseType.Presence:
ResponseToUserCallbackForSubscribe <T>(result, type, channels, userCallback, cipherKey, channelCallbacks, jsonPluggableLibrary);
break;
case ResponseType.Leave:
//No response to callback
break;
case ResponseType.Publish:
case ResponseType.DetailedHistory:
case ResponseType.HereNow:
case ResponseType.GlobalHereNow:
case ResponseType.WhereNow:
case ResponseType.Time:
case ResponseType.GrantAccess:
case ResponseType.AuditAccess:
case ResponseType.RevokeAccess:
case ResponseType.GetUserState:
case ResponseType.SetUserState:
case ResponseType.PushRegister:
case ResponseType.PushRemove:
case ResponseType.PushGet:
case ResponseType.PushUnregister:
CheckResultListAndCallCallback(result, userCallback, jsonPluggableLibrary);
break;
default:
break;
}
}
internal static void ResponseToUserCallbackForSubscribe <T> (List <object> result, ResponseType type, string[] channels,
Action <T> userCallback, string cipherKey, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, IJsonPluggableLibrary jsonPluggableLibrary)
{
var messages = (from item in result
select item as object).ToArray();
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, result: {1}", DateTime.Now.ToString(), result.ToString()), LoggingMethod.LevelInfo);
#endif
if (messages != null && messages.Length > 0)
{
ResponseToUserCallbackForSubscribeSendCallbacks <T>(result, cipherKey, channelCallbacks, jsonPluggableLibrary, messages);
}
}
internal static void ResponseToUserCallbackForSubscribeSendCallbacks <T> (List <object> result, string cipherKey, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, IJsonPluggableLibrary jsonPluggableLibrary, object[] messages)
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, messageList typeOF: {1}", DateTime.Now.ToString(),
messages [0].GetType().ToString()), LoggingMethod.LevelInfo);
#endif
var messageList = messages [0] as object[];
messageList = CreateMessageList(result, messageList);
string[] messageChannels = messages [2].ToString().Split(',');
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, (messageChannels: {1}", DateTime.Now.ToString(), messageChannels.ToString()), LoggingMethod.LevelInfo);
#endif
if (messageList != null && messageList.Length > 0)
{
for (int messageIndex = 0; messageIndex < messageList.Length; messageIndex++)
{
string currentChannel = (messageChannels.Length == 1) ? (string)messageChannels[0] : (string)messageChannels[messageIndex];
var itemMessage = AddMessageToList(cipherKey, jsonPluggableLibrary, messages, messageIndex, currentChannel, messageList);
PubnubCallbacks.SendCallbacksBasedOnType <T>(channelCallbacks, jsonPluggableLibrary, currentChannel, itemMessage);
}
}
}
internal static void ProcessWrapResultBasedOnResponseTypeException <T> (ResponseType type, string[] channels,
Action <PubnubClientError> errorCallback, SafeDictionary <PubnubChannelCallbackKey, object> channelCallbacks,
PubnubErrorFilter.Level errorLevel, Exception ex)
{
if (channels != null)
{
if (type == ResponseType.Subscribe || type == ResponseType.Presence)
{
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (ex, channels, PubnubErrorSeverity.Critical,
channelCallbacks, false, PubnubErrorCode.None, type, errorLevel);
}
else
{
if (errorCallback != null)
{
PubnubCallbacks.CallErrorCallback <T> (ex, null, string.Join(",", channels), PubnubErrorCode.None,
PubnubErrorSeverity.Critical, errorCallback, errorLevel);
}
}
}
}
internal static void FireErrorCallbacksForAllChannels <T> (string message, RequestState <T> requestState, string[] channels,
PubnubErrorSeverity severity, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, bool callbackObjectType, PubnubErrorCode errorType,
ResponseType responseType, PubnubErrorFilter.Level errorLevel)
{
for (int index = 0; index < channels.Length; index++)
{
string activeChannel = channels [index].ToString();
PubnubClientError error = Helpers.CreatePubnubClientError <T> (message, requestState,
activeChannel, errorType, severity);
PubnubCallbacks.FireErrorCallback <T> (activeChannel, channelCallbacks,
callbackObjectType, responseType, errorLevel, error);
}
}
/// <summary>
/// Gets the result by wrapping the json response based on the request
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="type"></param>
/// <param name="jsonString"></param>
/// <param name="channels"></param>
/// <param name="reconnect"></param>
/// <param name="lastTimetoken"></param>
/// <param name="errorCallback"></param>
/// <returns></returns>
public static List <object> WrapResultBasedOnResponseType <T> (ResponseType type, string jsonString, string[] channels,
Action <PubnubClientError> errorCallback, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, IJsonPluggableLibrary jsonPluggableLibrary, PubnubErrorFilter.Level errorLevel, string cipherKey)
{
List <object> result = new List <object> ();
try {
string multiChannel = (channels != null) ? string.Join(",", channels) : "";
if (!string.IsNullOrEmpty(jsonString))
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, jsonString = {1}", DateTime.Now.ToString(), jsonString), LoggingMethod.LevelInfo);
#endif
object deSerializedResult = jsonPluggableLibrary.DeserializeToObject(jsonString);
List <object> result1 = ((IEnumerable)deSerializedResult).Cast <object> ().ToList();
if (result1 != null && result1.Count > 0)
{
result = result1;
}
switch (type)
{
case ResponseType.DetailedHistory:
result = DecodeDecryptLoop(result, channels, errorCallback, cipherKey, jsonPluggableLibrary, errorLevel);
result.Add(multiChannel);
break;
case ResponseType.Time:
Int64[] c = deSerializedResult as Int64[];
if ((c != null) && (c.Length > 0))
{
result = new List <object> ();
result.Add(c [0]);
}
break;
case ResponseType.Subscribe:
case ResponseType.Presence:
case ResponseType.Leave:
case ResponseType.Publish:
case ResponseType.PushRegister:
case ResponseType.PushRemove:
case ResponseType.PushGet:
case ResponseType.PushUnregister:
result.Add(multiChannel);
break;
case ResponseType.GrantAccess:
case ResponseType.AuditAccess:
case ResponseType.RevokeAccess:
case ResponseType.GetUserState:
case ResponseType.SetUserState:
case ResponseType.WhereNow:
case ResponseType.HereNow:
result = DeserializeAndAddToResult(jsonString, multiChannel, jsonPluggableLibrary, true);
break;
case ResponseType.GlobalHereNow:
result = DeserializeAndAddToResult(jsonString, multiChannel, jsonPluggableLibrary, false);
break;
default:
break;
}
}
#if (ENABLE_PUBNUB_LOGGING)
else
{
LoggingMethod.WriteToLog(string.Format("DateTime {0}, json string null ", DateTime.Now.ToString()), LoggingMethod.LevelInfo);
}
#endif
} catch (Exception ex) {
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, WrapResultBasedOnResponseType exception: {1} ", DateTime.Now.ToString(), ex.ToString()), LoggingMethod.LevelError);
#endif
ProcessWrapResultBasedOnResponseTypeException <T> (type, channels, errorCallback, channelCallbacks, errorLevel, ex);
}
return(result);
}
internal static void CheckSubscribedChannelsAndSendCallbacks <T> (string[] channels, bool isPresence,
ResponseType type, int pubnubNetworkCheckRetries, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, PubnubErrorFilter.Level errorLevel)
{
if (channels != null && channels.Length > 0)
{
string message = string.Format("Unsubscribed after {0} failed retries", pubnubNetworkCheckRetries);;
PubnubErrorCode pnErrorCode = PubnubErrorCode.UnsubscribedAfterMaxRetries;
if (isPresence)
{
message = string.Format("Presence Unsubscribed after {0} failed retries", pubnubNetworkCheckRetries);
pnErrorCode = PubnubErrorCode.PresenceUnsubscribedAfterMaxRetries;
}
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (message, null, channels,
PubnubErrorSeverity.Critical, channelCallbacks,
false, pnErrorCode, type, errorLevel);
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, {1} Subscribe JSON network error response={2}",
DateTime.Now.ToString(), (isPresence)?"Presence":"", message), LoggingMethod.LevelInfo);
#endif
}
}
internal static void SendConnectCallback <T> (IJsonPluggableLibrary jsonPluggableLibrary,
List <object> connectResult, string channel, ResponseType type, SafeDictionary <PubnubChannelCallbackKey, object> channelCallbacks)
{
var callbackKey = GetPubnubChannelCallbackKey(channel, type);
if (channelCallbacks.Count > 0 && channelCallbacks.ContainsKey(callbackKey))
{
PubnubChannelCallback <T> currentPubnubCallback = channelCallbacks [callbackKey] as PubnubChannelCallback <T>;
if (currentPubnubCallback != null && currentPubnubCallback.ConnectCallback != null)
{
PubnubCallbacks.GoToCallback <T> (connectResult, currentPubnubCallback.ConnectCallback, jsonPluggableLibrary);
}
}
}
internal static void ResponseCallbackExceptionHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
Exception ex, string channel, SafeDictionary <PubnubChannelCallbackKey, object> channelCallbacks,
PubnubErrorFilter.Level errorLevel)
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, Process Response Exception: = {1}", DateTime.Now.ToString(), ex.ToString()), LoggingMethod.LevelError);
#endif
if (requestState.Channels != null)
{
if (requestState.RespType == ResponseType.Subscribe ||
requestState.RespType == ResponseType.Presence)
{
PubnubCallbacks.FireErrorCallbacksForAllChannels(ex, requestState,
PubnubErrorSeverity.Warn, channelCallbacks,
false, PubnubErrorCode.None, errorLevel);
}
else
{
PubnubCallbacks.CallErrorCallback <T> (ex, requestState, channel,
PubnubErrorCode.None, PubnubErrorSeverity.Critical, requestState.ErrorCallback, errorLevel);
}
}
ProcessResponseCallbackExceptionHandler <T> (ex, requestState, errorLevel);
}
internal static List <string> RemoveDuplicateChannelsAndCheckForAlreadySubscribedChannels <T>(ResponseType type,
string channel, Action <PubnubClientError> errorCallback, string[] rawChannels, List <string> validChannels,
bool networkConnection, SafeDictionary <string, long> multiChannelSubscribe, PubnubErrorFilter.Level errorLevel)
{
if (rawChannels.Length > 0 && networkConnection)
{
if (rawChannels.Length != rawChannels.Distinct().Count())
{
rawChannels = rawChannels.Distinct().ToArray();
string message = "Detected and removed duplicate channels";
PubnubCallbacks.CallErrorCallback <T>(message, null, channel, PubnubErrorCode.DuplicateChannel, PubnubErrorSeverity.Info, errorCallback, errorLevel);
}
for (int index = 0; index < rawChannels.Length; index++)
{
if (rawChannels[index].Trim().Length > 0)
{
string channelName = rawChannels[index].Trim();
if (type == ResponseType.Presence)
{
channelName = string.Format("{0}{1}", channelName, Utility.PresenceChannelSuffix);
}
if (multiChannelSubscribe.ContainsKey(channelName))
{
string message = string.Format("{0}Already subscribed", (Utility.IsPresenceChannel(channelName)) ? "Presence " : "");
PubnubErrorCode errorType = (Utility.IsPresenceChannel(channelName)) ? PubnubErrorCode.AlreadyPresenceSubscribed : PubnubErrorCode.AlreadySubscribed;
PubnubCallbacks.CallErrorCallback <T>(message, null, channelName.Replace(Utility.PresenceChannelSuffix, ""), errorType, PubnubErrorSeverity.Info, errorCallback, errorLevel);
}
else
{
validChannels.Add(channelName);
}
}
}
}
return(validChannels);
}
internal static void ResponseCallbackWebExceptionHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
WebException webEx, string channel, SafeDictionary <PubnubChannelCallbackKey, object> channelCallbacks,
PubnubErrorFilter.Level errorLevel)
{
if (requestState.Channels != null || requestState.RespType == ResponseType.Time)
{
if (requestState.RespType == ResponseType.Subscribe ||
requestState.RespType == ResponseType.Presence)
{
if (webEx.Message.IndexOf("The request was aborted: The request was canceled") == -1 ||
webEx.Message.IndexOf("Machine suspend mode enabled. No request will be processed.") == -1)
{
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (webEx, requestState,
PubnubErrorSeverity.Warn, channelCallbacks,
true, errorLevel);
}
}
else
{
PubnubCallbacks.CallErrorCallback <T> (webEx, requestState, channel,
PubnubErrorSeverity.Warn, requestState.ErrorCallback, errorLevel);
}
}
ProcessResponseCallbackWebExceptionHandler <T> (webEx, requestState, channel, errorLevel);
}
internal static void FireErrorCallbacksForAllChannels <T> (WebException webEx, RequestState <T> requestState,
PubnubErrorSeverity severity, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, bool callbackObjectType, PubnubErrorFilter.Level errorLevel)
{
for (int index = 0; index < requestState.Channels.Length; index++)
{
string activeChannel = requestState.Channels [index].ToString();
PubnubClientError error = Helpers.CreatePubnubClientError <T> (webEx, requestState, activeChannel,
severity);
FireErrorCallback <T> (activeChannel, channelCallbacks,
callbackObjectType, requestState.RespType, errorLevel, error);
}
}
