internal static void ResponseCallbackWebExceptionHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
WebException webEx,
PubnubErrorFilter.Level errorLevel)
{
if ((requestState != null) && (requestState.ChannelEntities != null || requestState.RespType != ResponseType.Time))
{
if (requestState.RespType.Equals(ResponseType.SubscribeV2) ||
requestState.RespType.Equals(ResponseType.PresenceV2)
)
{
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, errorLevel);
}
}
else
{
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (webEx, requestState,
PubnubErrorSeverity.Warn, errorLevel);
}
}
ProcessResponseCallbackWebExceptionHandler <T> (webEx, requestState, errorLevel);
}
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 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 SendCallbacksBasedOnType <T>(SafeDictionary <PubnubChannelCallbackKey, object> channelCallbacks,
IJsonPluggableLibrary jsonPluggableLibrary, string currentChannel, List <object> itemMessage)
{
var callbackKey = PubnubCallbacks.GetPubnubChannelCallbackKey(currentChannel,
(Utility.IsPresenceChannel(currentChannel)) ? ResponseType.Presence : ResponseType.Subscribe);
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, currentChannel: {1}", DateTime.Now.ToString(),
currentChannel.ToString()), LoggingMethod.LevelInfo);
#endif
if (channelCallbacks.Count > 0 && channelCallbacks.ContainsKey(callbackKey))
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, typeof(T): {1}", DateTime.Now.ToString(), typeof(T).ToString()), LoggingMethod.LevelInfo);
#endif
if ((typeof(T) == typeof(string) && channelCallbacks[callbackKey].GetType().Name.Contains("[System.String]")) ||
(typeof(T) == typeof(object) && channelCallbacks[callbackKey].GetType().Name.Contains("[System.Object]")))
{
CallCallback <T>(callbackKey, channelCallbacks, jsonPluggableLibrary, itemMessage);
}
else if (channelCallbacks[callbackKey].GetType().FullName.Contains("[System.String"))
{
CallCallbackKnownType <string>(callbackKey, channelCallbacks, jsonPluggableLibrary, itemMessage);
}
else if (channelCallbacks[callbackKey].GetType().FullName.Contains("[System.Object"))
{
CallCallbackKnownType <object>(callbackKey, channelCallbacks, jsonPluggableLibrary, itemMessage);
}
}
}
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 CommonExceptionHandler <T> (RequestState <T> requestState, string message, bool requestTimeout,
PubnubErrorFilter.Level errorLevel
)
{
if (requestTimeout)
{
message = "Operation Timeout";
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, {1} CommonExceptionHandler response={2}", DateTime.Now.ToString(),
requestState.RespType.ToString(), message), LoggingMethod.LevelInfo);
#endif
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (message, requestState,
PubnubErrorSeverity.Critical, Helpers.GetTimeOutErrorCode(requestState.RespType), errorLevel);
}
else
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, {1} CommonExceptionHandler response={2}", DateTime.Now.ToString(), requestState.RespType.ToString(), message), LoggingMethod.LevelInfo);
#endif
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (message, requestState,
PubnubErrorSeverity.Critical, PubnubErrorCode.None, errorLevel);
}
}
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 ResponseCallbackErrorOrTimeoutHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
PubnubErrorFilter.Level errorLevel)
{
WebException webEx = new WebException(cea.Message);
if ((cea.Message.Contains("NameResolutionFailure") ||
cea.Message.Contains("ConnectFailure") ||
cea.Message.Contains("ServerProtocolViolation") ||
cea.Message.Contains("ProtocolError")
))
{
webEx = new WebException("Network connnect error", WebExceptionStatus.ConnectFailure);
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (cea.Message, requestState,
PubnubErrorSeverity.Warn, PubnubErrorCode.NoInternetRetryConnect, errorLevel);
}
else if (cea.IsTimeout || Utility.CheckRequestTimeoutMessageInError(cea))
{
}
else if ((cea.Message.Contains("403")) ||
(cea.Message.Contains("java.io.FileNotFoundException")) ||
((PubnubUnity.Version.Contains("UnityWeb")) && (cea.Message.Contains("Failed downloading"))))
{
CreateErrorCodeAndCallErrorCallback <T> (403, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("500"))
{
CreateErrorCodeAndCallErrorCallback <T> (500, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("502"))
{
CreateErrorCodeAndCallErrorCallback <T> (502, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("503"))
{
CreateErrorCodeAndCallErrorCallback <T> (503, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("504"))
{
CreateErrorCodeAndCallErrorCallback <T> (504, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("414"))
{
CreateErrorCodeAndCallErrorCallback <T> (414, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("451"))
{
CreateErrorCodeAndCallErrorCallback <T> (451, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("481"))
{
CreateErrorCodeAndCallErrorCallback <T> (481, cea, requestState, errorLevel);
}
else
{
CreateErrorCodeAndCallErrorCallback <T> (400, cea, requestState, errorLevel);
}
ProcessResponseCallbackWebExceptionHandler <T> (webEx, requestState, errorLevel);
}
internal static void CheckResultListAndCallCallback <T>(List <object> result, Action <T> userCallback,
IJsonPluggableLibrary jsonPluggableLibrary)
{
if (result != null && result.Count > 0)
{
PubnubCallbacks.GoToCallback <T> (result, userCallback, jsonPluggableLibrary);
}
}
internal static void ResponseCallbackErrorOrTimeoutHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState, string channel,
PubnubErrorFilter.Level errorLevel, IJsonPluggableLibrary jsonPluggableLibrary)
{
WebException webEx = new WebException(cea.Message);
if ((cea.Message.Contains("NameResolutionFailure") ||
cea.Message.Contains("ConnectFailure") ||
cea.Message.Contains("ServerProtocolViolation") ||
cea.Message.Contains("ProtocolError")
))
{
webEx = new WebException("Network connnect error", WebExceptionStatus.ConnectFailure);
PubnubCallbacks.CallErrorCallback <T> (cea.Message, null, channel,
PubnubErrorCode.NoInternetRetryConnect, PubnubErrorSeverity.Warn, requestState.ErrorCallback, errorLevel);
}
else if (cea.IsTimeout || Utility.CheckRequestTimeoutMessageInError(cea))
{
}
else if ((cea.Message.Contains("403")) ||
(cea.Message.Contains("java.io.FileNotFoundException")) ||
((PubnubUnity.Version.Contains("UnityWeb")) && (cea.Message.Contains("Failed downloading"))))
{
PubnubClientError error = new PubnubClientError(403, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("500"))
{
PubnubClientError error = new PubnubClientError(500, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("502"))
{
PubnubClientError error = new PubnubClientError(503, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("503"))
{
PubnubClientError error = new PubnubClientError(503, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("504"))
{
PubnubClientError error = new PubnubClientError(504, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("414"))
{
PubnubClientError error = new PubnubClientError(414, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else
{
PubnubClientError error = new PubnubClientError(400, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
ProcessResponseCallbackWebExceptionHandler <T> (webEx, requestState, channel, errorLevel);
}
internal static void CreateErrorCodeAndCallErrorCallback <T> (int statusCode, CustomEventArgs <T> cea, RequestState <T> requestState,
PubnubErrorFilter.Level errorLevel)
{
PubnubClientError error = new PubnubClientError(statusCode, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server,
requestState.Request, requestState.Response, cea.Message, requestState.ChannelEntities);
PubnubCallbacks.CallErrorCallback <T> (requestState.ErrorCallback, requestState.ChannelEntities,
error, errorLevel);
}
internal static void PushNotificationExceptionHandler <T>(RequestState <T> requestState, bool requestTimeout,
PubnubErrorFilter.Level errorLevel)
{
if (requestTimeout)
{
string message = (requestTimeout) ? "Operation Timeout" : "Network connnect error";
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, PushExceptionHandler response={1}", DateTime.Now.ToString(), message), LoggingMethod.LevelInfo);
#endif
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (message, requestState,
PubnubErrorSeverity.Critical, PubnubErrorCode.PushNotificationTimeout, errorLevel);
}
}
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 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);
}
}
internal static object DecodeMessage(PubnubCrypto aes, object element, string[] channels,
Action <PubnubClientError> errorCallback, IJsonPluggableLibrary jsonPluggableLibrary,
PubnubErrorFilter.Level errorLevel)
{
string decryptMessage = "";
try {
decryptMessage = aes.Decrypt(element.ToString());
}
catch (Exception ex) {
decryptMessage = "**DECRYPT ERROR**";
string multiChannel = string.Join(",", channels);
PubnubCallbacks.CallErrorCallback <object> (ex, null, multiChannel, PubnubErrorCode.None,
PubnubErrorSeverity.Critical, errorCallback, errorLevel);
}
object decodeMessage = (decryptMessage == "**DECRYPT ERROR**") ? decryptMessage : jsonPluggableLibrary.DeserializeToObject(decryptMessage);
return(decodeMessage);
}
internal static void PushNotificationExceptionHandler <T>(string[] channels, bool requestTimeout,
Action <PubnubClientError> errorCallback, PubnubErrorFilter.Level errorLevel)
{
string channel = "";
if (channels != null)
{
channel = string.Join(",", channels);
}
if (requestTimeout)
{
string message = (requestTimeout) ? "Operation Timeout" : "Network connnect error";
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, PushExceptionHandler response={1}", DateTime.Now.ToString(), message), LoggingMethod.LevelInfo);
#endif
PubnubCallbacks.CallErrorCallback <T>(message, null, channel,
PubnubErrorCode.PushNotificationTimeout, PubnubErrorSeverity.Critical, errorCallback, errorLevel);
}
}
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 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 ResponseCallbackExceptionHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
Exception ex, 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.ChannelEntities != null)
{
if (requestState.RespType.Equals(ResponseType.SubscribeV2) ||
requestState.RespType.Equals(ResponseType.PresenceV2)
)
{
PubnubCallbacks.FireErrorCallbacksForAllChannels(ex, requestState,
PubnubErrorSeverity.Warn, PubnubErrorCode.None, errorLevel);
}
else
{
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (ex, requestState,
PubnubErrorSeverity.Critical, PubnubErrorCode.None, errorLevel);
}
}
ProcessResponseCallbackExceptionHandler <T> (ex, requestState, errorLevel);
}
internal static void CommonExceptionHandler <T> (string message, string channelName, bool requestTimeout,
Action <PubnubClientError> errorCallback, PubnubErrorFilter.Level errorLevel, ResponseType responseType)
{
if (requestTimeout)
{
message = "Operation Timeout";
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, {1} response={2}", DateTime.Now.ToString(), responseType.ToString(), message), LoggingMethod.LevelInfo);
#endif
PubnubCallbacks.CallErrorCallback <T> (message, null, channelName,
Helpers.GetTimeOutErrorCode(responseType), PubnubErrorSeverity.Critical, errorCallback, errorLevel);
}
else
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, {1} response={2}", DateTime.Now.ToString(), responseType.ToString(), message), LoggingMethod.LevelInfo);
#endif
PubnubCallbacks.CallErrorCallback <T> (message, null, channelName,
PubnubErrorCode.None, PubnubErrorSeverity.Critical, errorCallback, 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);
}
