public override void OnActivated(UIApplication application) { // Restart any tasks that were paused (or not yet started) while the application was inactive. // If the application was previously in the background, optionally refresh the user interface. LogUtility.LogMessage("OnActivated called, App is active."); ServiceContainer.InvalidateCache(); // invalidate cache after backgrounding app NotificationUtility.PostNotification(NotificationType.Activated); }
/// <summary> /// Takes appropriate actions up on failed reconnect /// </summary> private static void OnFailure() { Stop(); //if auth failure timeout, redirect to login screen if (IsAuthFailure) { NotificationUtility.PostNotification(NotificationType.AuthFailure); } }
/// <summary> /// Internally sets the instance connection state /// </summary> /// <param name="state">The state value to set</param> /// <param name="message">Optional message to display on banner</param> private static void SetState(ConnectionState state, string message = null) { state.Message = message; if (_state != state) { LogUtility.LogMessage(String.Format("Connection state set to {0}", state.ToString())); _state = state; NotificationUtility.PostNotification(NotificationType.ConnectionStateChanged); } }
/// <summary> /// Sets the active alert count. /// </summary> /// <param name="count">The value to set</param> public static void SetActiveAlertsCount(int?count) { if (count.HasValue) { if (_activeAlertsCount != count.Value) { _activeAlertsCount = count.Value; NotificationUtility.PostNotification(NotificationType.AlertsCountChanged, null); } } }
/// <summary> /// Handles a failed websocket request /// </summary> /// <param name="client">The websocket client which sent the request</param> /// <param name="args">Arguments associated with failure</param> private static void HandleFailedRequest(IWebSocketsClient client, RequestFailureEventArgs args) { LogUtility.LogMessage(String.Format("Request Failure (reason: {0})", Enum.GetName(typeof(RequestFailureReason), args.FailureReason))); bool tryReconnect = false; string message = null; switch (args.FailureReason) { case RequestFailureReason.Auth: tryReconnect = false; message = "authentication problem"; NotificationUtility.PostNotification(NotificationType.AuthFailure); break; case RequestFailureReason.Timeout: tryReconnect = ReconnectIsAllowed(); message = "timeout"; break; case RequestFailureReason.ServerDown: tryReconnect = ReconnectIsAllowed(); message = "server down"; break; case RequestFailureReason.Network: tryReconnect = ReconnectIsAllowed(); message = "network issue"; break; case RequestFailureReason.ServerRequestedReconnect: tryReconnect = ReconnectIsAllowed(); message = "server requested reconnect"; break; case RequestFailureReason.Error: break; } if (tryReconnect) { SetState(ConnectionState.Disconnected, message); ReconnectProcess.Begin(args.ForegroundAction, args.OnResume, args.Request, args.FailureReason); } }
/// <summary> /// Does the work of sending a call to the server, and waiting for the response. /// </summary> /// <param name="jsonRequest">The request to send</param> /// <returns>A Task result with the response</returns> private Task <TResponse> Send <TResponse>(IApiRequest jsonRequest, string channel, bool silentMode = false) where TResponse : IApiResponse, new() { TResponse output = default(TResponse); return(Task.Run(() => { ExceptionUtility.Try(() => { string jsonRequestString = JsonUtility.Serialize(jsonRequest); string jsonRequestStringForLogging = jsonRequestString.Replace(User.Current.Password, "********"); LogUtility.LogMessage(String.Format("{2}: Sending Request to {0}: {1}", this.Url, FormatJsonForLogging(jsonRequestStringForLogging), this._instanceId.ToString())); var waitHandle = new AutoResetEvent(false); bool gotResponse = false; Action <IApiResponse> receivedResponse = (r) => { gotResponse = true; if (r is Lib.Domain.Responses.ConnectionResponse && ((ConnectionResponse)r).IsSuccessful) { NotificationUtility.PostNotification(NotificationType.Reconnected); } if (r is Lib.Domain.Responses.ErrorResponse) { output = ResponseFactory.ParseResponse <TResponse>(r.RawResponse); } else { try { output = (TResponse)r; } catch (System.InvalidCastException ice) { LogUtility.LogException(ice, String.Format("The server returned a type of response that was not expected. The type of response expected was {0}", (typeof(TResponse)).Name), LogSeverity.Warn); output = default(TResponse); } } if (r.IsAuthFailure) { output = ResponseFactory.FabricateLoginFailureResponse <TResponse>(jsonRequest); } gotResponse = true; waitHandle.Set(); }; RegisterWaitingForResponse(channel, receivedResponse); if (_client != null) { _client.Send(new NSString(jsonRequestString)); waitHandle.WaitOne(DefaultSendTimeoutMs); UnregisterWaitingForResponse(channel); } //here we will fabricate an error response for case of timeout if (output == null && !gotResponse) { output = ResponseFactory.FabricateRequestTimeoutResponse <TResponse>(jsonRequest); this.FireRequestFailureEvent(jsonRequest, null, RequestFailureReason.Timeout, foregroundAction: (!silentMode)); } }); return output; })); }
/// <summary> /// Hide the reconnecting banner /// </summary> private static void HideReconBanner() { _showingReconBar = false; NotificationUtility.PostNotification(NotificationType.HideReconnecting); }
/// <summary> /// Display the reconnecting banner /// </summary> private static void ShowReconBanner() { _showingReconBar = true; NotificationUtility.PostNotification(NotificationType.ShowReconnecting); }