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