protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { switch (powerStatus) { case PowerBroadcastStatus.BatteryLow: break; case PowerBroadcastStatus.OemEvent: break; case PowerBroadcastStatus.PowerStatusChange: break; case PowerBroadcastStatus.QuerySuspend: break; case PowerBroadcastStatus.QuerySuspendFailed: break; case PowerBroadcastStatus.ResumeAutomatic: break; case PowerBroadcastStatus.ResumeCritical: break; case PowerBroadcastStatus.ResumeSuspend: break; case PowerBroadcastStatus.Suspend: break; } return base.OnPowerEvent(powerStatus); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { try { switch (powerStatus) { case PowerBroadcastStatus.QuerySuspend: TerminateAllCommThreads(); StopDevice(); break; case PowerBroadcastStatus.ResumeSuspend: TerminateAllCommThreads(); StartDevice(); InitializeAppManager(); break; case PowerBroadcastStatus.Suspend: TerminateAllCommThreads(); StopDevice(); break; case PowerBroadcastStatus.ResumeAutomatic: TerminateAllCommThreads(); StartDevice(); InitializeAppManager(); break; } } catch { return false; } return base.OnPowerEvent(powerStatus); }
/// <summary> /// Handles power events published by WsapmService. /// </summary> /// <param name="powerStatus">The power status to handle.</param> public void OnPowerEvent(PowerBroadcastStatus powerStatus) { try { switch (powerStatus) { case PowerBroadcastStatus.ResumeAutomatic: // System woken up (by wake timer, on user input, WoL, etc.). // ResumeAutomatic will always appear when the computer wakes up from standby. When these is any user input (i.e. the user is present), a ResumeSuspend will appear afterwards. // Reset windows idle timer, a ResumeSuspend should be raised afterwards. // Start the WSAPM timers not generally when a ResumeAutomatic appears, just start them when WSAPM scheduled automatic wake! WsapmLog.Log.WriteLine(Resources.Wsapm_Core.WsapmManager_ResumeAutomatic, LogMode.Normal); this.lastWakeTime = DateTime.Now; StartMonitoringTimer(); HandleResumeActions(); break; case PowerBroadcastStatus.Suspend: // System gets suspended. this.lastWakeTime = null; StopMonitoringTimer(); WsapmLog.Log.WriteLine(Resources.Wsapm_Core.WsapmManager_Suspend, LogMode.Normal); break; default: break; } } catch (Exception ex) { WriteErrorLog(ex); } }
/// <summary> /// Allows Connection Monitor service to publish a ServicePowerEvent event to subscribers /// </summary> public void ServicePowerEvent(PowerBroadcastStatus status) { foreach (IConMonServiceEventsCallBack subscriber in _subscribers) { subscriber.OnServicePowerEvent(status); } }
protected override bool OnPowerEvent(PowerBroadcastStatus status) { try { if (ctx.EventLog) { if (status == PowerBroadcastStatus.Suspend) { EventLog.WriteEntry("Entering Standby"); } if (status == PowerBroadcastStatus.ResumeSuspend) { if (this[typeof(PowerBroadcastFallback)] != null) { return(true); } EventLog.WriteEntry("Resuming Operation"); } } PowerChange?.Invoke(this, new PowerChangeEvent { Status = status }); } catch (Exception e) { EventLog.WriteEntry(e.ToString(), EventLogEntryType.Error, 99); } return(true); }
/// <summary> /// Fires when a power event on the computer is happening /// </summary> /// <param name="powerStatus"></param> /// <returns>Boolean indicating whether to continue the powerevent</returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { const string MemberName = "OnPowerEvent"; using (new Tracer(MemberName)) { try { LogMessage("Power mode event fired" + powerStatus.ToString() + ". Determining action to take", TraceEventType.Information); if (powerStatus == PowerBroadcastStatus.ResumeAutomatic || powerStatus == PowerBroadcastStatus.ResumeCritical || powerStatus == PowerBroadcastStatus.ResumeSuspend) { LogMessage("System is resuming from hibernation! Restarting ConMon Service Events", TraceEventType.Verbose); this.StartupHost(); } else if (powerStatus == PowerBroadcastStatus.Suspend) { LogMessage("System is hibernating! Stopping ConMon Service Events", TraceEventType.Verbose); StopAndCleanupHost(); } } catch (Exception ex) { Logger.Write(ex); } } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.Suspend || powerStatus == PowerBroadcastStatus.ResumeSuspend || powerStatus == PowerBroadcastStatus.ResumeAutomatic) { SerialPort port = new SerialPort("COM3", 9600, Parity.None, 8, StopBits.One); try { port.Open(); } catch (Exception e) { return(true); } if (powerStatus == PowerBroadcastStatus.Suspend) { port.WriteLine("Sleep"); } else { port.WriteLine("Wake"); } try { port.Close(); } catch { return(true); } } return(true); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { switch (powerStatus) { case PowerBroadcastStatus.QuerySuspendFailed: OnStart(null); break; case PowerBroadcastStatus.ResumeAutomatic: case PowerBroadcastStatus.ResumeCritical: case PowerBroadcastStatus.ResumeSuspend: OnStart(null); break; case PowerBroadcastStatus.QuerySuspend: case PowerBroadcastStatus.Suspend: OnSuspend(); break; default: break; } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { switch (powerStatus) { case PowerBroadcastStatus.BatteryLow: case PowerBroadcastStatus.OemEvent: case PowerBroadcastStatus.PowerStatusChange: case PowerBroadcastStatus.QuerySuspend: this.Flush(); return(true); case PowerBroadcastStatus.ResumeAutomatic: case PowerBroadcastStatus.ResumeCritical: case PowerBroadcastStatus.ResumeSuspend: if (this.autoPaused) { Log.Notice("Resuming service."); this.autoPaused = false; this.OnContinue(); } return(true); case PowerBroadcastStatus.Suspend: this.autoPaused = true; Log.Notice("Suspending service."); this.OnStop(); return(true); case PowerBroadcastStatus.QuerySuspendFailed: default: return(true); } }
private int ServiceCommandCallbackEx(int command, int eventType, IntPtr eventData, IntPtr eventContext) { if (command != NativeMethods.CONTROL_POWEREVENT) { ServiceCommandCallback(command); } else { try { PowerBroadcastStatus status = (PowerBroadcastStatus)eventType; bool statusResult = OnPowerEvent(status); WriteEventLogEntry(Res.GetString(Res.PowerEventOK)); if (!statusResult) { return(NativeMethods.BROADCAST_QUERY_DENY); } } catch (Exception e) { WriteEventLogEntry(Res.GetString(Res.PowerEventFailed, e.ToString()), EventLogEntryType.Error); } } return(NativeMethods.NO_ERROR); }
protected int PowerEventThreadWndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam) { if (msg == NativeMethods.WM_POWERBROADCAST) { PowerBroadcastStatus status = (PowerBroadcastStatus)wParam.ToInt32(); SafeLogD("PowerEventHandler received {0}", status); switch (status) { case PowerBroadcastStatus.QuerySuspend: var onQuerySuspend = OnQuerySuspend; if (onQuerySuspend != null) { if (!onQuerySuspend()) { return(NativeMethods.BROADCAST_QUERY_DENY); } } break; default: var onPowerEvent = OnPowerEvent; if (onPowerEvent != null) { onPowerEvent(status); } break; } } return(NativeMethods.DefWindowProc(hWnd, msg, wParam, lParam)); }
/// <summary> /// OnPowerEvent(): Useful for detecting power status changes, /// such as going into Suspend mode or Low Battery for laptops. /// </summary> /// <param name="powerStatus">The Power Broadcase Status (BatteryLow, Suspend, etc.)</param> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { // Send the event to the core m_alphaCore.OnPowerEvent(powerStatus); return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { Logger.Debug("Power Event: {0}", powerStatus); switch (powerStatus) { case PowerBroadcastStatus.QuerySuspendFailed: Logger.Warn("System failed to enter Suspend state!"); OnStart(null); break; case PowerBroadcastStatus.ResumeAutomatic: OnStart(null); break; case PowerBroadcastStatus.ResumeCritical: case PowerBroadcastStatus.ResumeSuspend: break; case PowerBroadcastStatus.QuerySuspend: case PowerBroadcastStatus.Suspend: OnSuspend(); break; default: break; } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { switch (powerStatus) { case PowerBroadcastStatus.BatteryLow: break; case PowerBroadcastStatus.OemEvent: break; case PowerBroadcastStatus.PowerStatusChange: break; case PowerBroadcastStatus.QuerySuspend: break; case PowerBroadcastStatus.QuerySuspendFailed: break; case PowerBroadcastStatus.ResumeAutomatic: break; case PowerBroadcastStatus.ResumeCritical: break; case PowerBroadcastStatus.ResumeSuspend: break; case PowerBroadcastStatus.Suspend: break; } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { SystemEvents.PowerModeChanged += new PowerModeChangedEventHandler((s, e) => { switch (e.Mode) { case PowerModes.Suspend: break; case PowerModes.Resume: break; } }); switch (powerStatus) { case PowerBroadcastStatus.Suspend: _numMonitors = 0; Logging.LogEvents("Sleep"); _sleeping = true; break; case PowerBroadcastStatus.ResumeSuspend: _numMonitors = SystemStats.GetNumMonitors(); Logging.LogEvents("Wake"); _sleeping = false; break; } return(base.OnPowerEvent(powerStatus)); }
/// <summary> /// Useful for detecting power status changes, /// such as going into Suspend mode or Low Battery for laptops. /// </summary> /// <param name="powerStatus">The Power Broadcast Status /// (BatteryLow, Suspend, etc.)</param> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { // // handle power events here // return(base.OnPowerEvent(powerStatus)); }
/// <summary> /// Handle power events, such as hibernation. /// </summary> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (imapProxies != null) { foreach (ImapProxy imapProxy in imapProxies) { imapProxy.ProcessPowerEvent((int)powerStatus); } imapProxies.Clear(); } if (pop3Proxies != null) { foreach (Pop3Proxy pop3Proxy in pop3Proxies) { pop3Proxy.ProcessPowerEvent((int)powerStatus); } pop3Proxies.Clear(); } if (smtpProxies != null) { foreach (SmtpProxy smtpProxy in smtpProxies) { smtpProxy.ProcessPowerEvent((int)powerStatus); } smtpProxies.Clear(); } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if ((activemodules & Modules.Power) == Modules.Power) { string details = ""; switch (powerStatus) { case PowerBroadcastStatus.BatteryLow: details = String.Format("WARNING Baterry low, {0}% remaining.", PowerMonitor.BatteryCharge()); le = new LogEntry(Logfile.FullName, (uint)LogEntryIDs.BatteryLow, details, machine, username); break; case PowerBroadcastStatus.PowerStatusChange: if (PowerMonitor.ACPowerPluggedIn()) { details = String.Format("Power Status Changed: System runs on AC power."); le = new LogEntry(Logfile.FullName, (uint)LogEntryIDs.PowerChangedOnAC, details, machine, username); } else { details = String.Format("Power Status Changed: System runs on battery."); le = new LogEntry(Logfile.FullName, (uint)LogEntryIDs.PowerChangedOnBattery, details, machine, username); } break; } } return(base.OnPowerEvent(powerStatus)); }
/// <summary> /// Called when [power event]. /// </summary> /// <param name="powerStatus">The power status.</param> /// <returns>System.Boolean.</returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { string message = $" powerStatus:{powerStatus} tcpServerTaskStatus:{this.TcpServerTask.Status} this.pollingTimer{this.pollingTimer.Enabled} "; this.OnLog(message); return(true); }
/// <summary> /// Overrides the power event handler. Method is called when a PC power event is detected, e.g. suspend /// </summary> /// <param name="powerStatus">The broadcasted power status</param> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { #if DEBUG WriteEventLogEntry("In OnPowerEvent"); #endif return(base.OnPowerEvent(powerStatus)); }
/// <summary> /// OnPowerEvent method of service. Gets called when a power event is raised. /// </summary> /// <param name="powerStatus"></param> /// <returns></returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { base.OnPowerEvent(powerStatus); this.WsapmManager.OnPowerEvent(powerStatus); return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.Suspend) { fileConverter.Stop(); } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ChoApplication.WriteToEventLog("OnPowerEvent()..."); if (_host != null) { return(_host.OnPowerEventService(powerStatus)); } return(true); }
/// <summary> /// OnPowerEvent(): Useful for detecting power status changes, /// such as going into Suspend mode or Low Battery for laptops. /// </summary> /// <param name="powerStatus">The Power Broadcast Status /// (BatteryLow, Suspend, etc.)</param> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { _log.Info("Service power event detected = {0}.", powerStatus.ToString()); _log.Flush(); if (powerStatus == PowerBroadcastStatus.Suspend) { OnStop(); } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.QuerySuspend) { // Deny suspend if required. if (_suspendLevel > SuspendLevel.None) return false; } return base.OnPowerEvent(powerStatus); }
// For Laptop protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus.HasFlag(PowerBroadcastStatus.Suspend)) { SendMailService.WriteErrorLog("System has been shutdown."); SendMailService.SendEmail(ServiceProperty.Email, "Service Report", "Your system has been down on " + DateTime.Now.ToLongTimeString()); } return(true); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.ResumeSuspend || powerStatus == PowerBroadcastStatus.ResumeAutomatic || powerStatus == PowerBroadcastStatus.ResumeCritical) { this.service.ReInitializeFanControl(); } return(true); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { switch (powerStatus) { case PowerBroadcastStatus.BatteryLow: _log.Info(() => string.Format("Service {0} pausing in response to [BATTERY LOW]", ServiceName)); PauseService(); _log.Info(() => string.Format("Service {0} paused", ServiceName)); return(true); //no clue as to what this OEM event is -- let's not do anything case PowerBroadcastStatus.OemEvent: //useless since we don't know if we've gone to battery, or A/C... could also be battery low //which will result in a shutdown case PowerBroadcastStatus.PowerStatusChange: return(false); //turn off our timer process case PowerBroadcastStatus.QuerySuspend: _log.Info(() => string.Format("Service {0} pausing in response to [SUSPEND REQUEST]", ServiceName)); PauseService(); _log.Info(() => string.Format("Service {0} paused", ServiceName)); return(true); case PowerBroadcastStatus.QuerySuspendFailed: _log.Info(() => string.Format("Service {0} starting in response to [SUSPEND REQUEST FAIL]", ServiceName)); return(true); //don't do anything yet as we will get a ResumeSuspend //of course that might not make sense as a server case PowerBroadcastStatus.ResumeAutomatic: return(true); case PowerBroadcastStatus.ResumeCritical: //recreate our resources _log.Info(() => string.Format("Service {0} starting in response to [RESUME FROM CRITICAL]", ServiceName)); StartService(); _log.Info(() => string.Format("Service {0} started", ServiceName)); return(true); //resuming our service, so start synchronizing again case PowerBroadcastStatus.ResumeSuspend: _log.Info(() => string.Format("Service {0} starting in response to [RESUME FROM SUSPEND]", ServiceName)); StartService(); _log.Info(() => string.Format("Service {0} started", ServiceName)); return(true); //we already paused our service in QuerySuspend case PowerBroadcastStatus.Suspend: return(true); } return(false); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.ResumeSuspend || powerStatus == PowerBroadcastStatus.ResumeAutomatic || powerStatus == PowerBroadcastStatus.ResumeCritical) { this.service.ReInitializeFanControl(); } return true; }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.ResumeAutomatic) // || powerStatus == PowerBroadcastStatus.ResumeSuspend) { Log($"Service powerEvent {powerStatus} at {DateTime.Now}"); ApplyConfiguraton(); } return(base.OnPowerEvent(powerStatus)); }
/// <summary> /// Executes when the computer's power status has changed. This applies to /// laptop computers when they go into suspended mode, which is not the same /// as a system shutdown. /// </summary> /// <param name="powerStatus"> /// A System.ServiceProcess.PowerBroadcastStatus that indicates a notification /// from the system about its power status. /// </param> /// <returns> /// When implemented in a derived class, the needs of your application determine /// what value to return. /// For example, if a QuerySuspend broadcast status is passed, you could cause /// your application to reject the query by returning false. /// </returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { try { LogMsg("OnPowerEvent(): {0}", powerStatus); } catch (Exception e) { LogMsg(e.ToString()); } return base.OnPowerEvent(powerStatus); }
/// <summary> /// Power Management strikes again /// </summary> /// <param name="powerStatus"> power status information</param> /// <returns>true on power on</returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.Suspend) { logger.WarnMethod("MFC detected that the system is about to go into suspend power mode."); } else if (powerStatus == PowerBroadcastStatus.ResumeSuspend) { logger.WarnMethod("MFC detected that the system has been resumed."); } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { switch (powerStatus) { case PowerBroadcastStatus.BatteryLow: _log.Info(() => string.Format("Service {0} pausing in response to [BATTERY LOW]", ServiceName)); PauseService(); _log.Info(() => string.Format("Service {0} paused", ServiceName)); return true; //no clue as to what this OEM event is -- let's not do anything case PowerBroadcastStatus.OemEvent: //useless since we don't know if we've gone to battery, or A/C... could also be battery low //which will result in a shutdown case PowerBroadcastStatus.PowerStatusChange: return false; //turn off our timer process case PowerBroadcastStatus.QuerySuspend: _log.Info(() => string.Format("Service {0} pausing in response to [SUSPEND REQUEST]", ServiceName)); PauseService(); _log.Info(() => string.Format("Service {0} paused", ServiceName)); return true; case PowerBroadcastStatus.QuerySuspendFailed: _log.Info(() => string.Format("Service {0} starting in response to [SUSPEND REQUEST FAIL]", ServiceName)); return true; //don't do anything yet as we will get a ResumeSuspend //of course that might not make sense as a server case PowerBroadcastStatus.ResumeAutomatic: return true; case PowerBroadcastStatus.ResumeCritical: //recreate our resources _log.Info(() => string.Format("Service {0} starting in response to [RESUME FROM CRITICAL]", ServiceName)); StartService(); _log.Info(() => string.Format("Service {0} started", ServiceName)); return true; //resuming our service, so start synchronizing again case PowerBroadcastStatus.ResumeSuspend: _log.Info(() => string.Format("Service {0} starting in response to [RESUME FROM SUSPEND]", ServiceName)); StartService(); _log.Info(() => string.Format("Service {0} started", ServiceName)); return true; //we already paused our service in QuerySuspend case PowerBroadcastStatus.Suspend: return true; } return false; }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.QuerySuspend) { // Deny suspend if required. if (_suspendLevel > SuspendLevel.None) { return(false); } } return(base.OnPowerEvent(powerStatus)); }
/// <summary> /// Executes when the computer's power status has changed. This applies to /// laptop computers when they go into suspended mode, which is not the same /// as a system shutdown. /// </summary> /// <param name="powerStatus"> /// A System.ServiceProcess.PowerBroadcastStatus that indicates a notification /// from the system about its power status. /// </param> /// <returns> /// When implemented in a derived class, the needs of your application determine /// what value to return. /// For example, if a QuerySuspend broadcast status is passed, you could cause /// your application to reject the query by returning false. /// </returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { try { LogMsg("OnPowerEvent(): {0}", powerStatus); } catch (Exception e) { LogMsg(e.ToString()); } return(base.OnPowerEvent(powerStatus)); }
protected override bool OnPowerEvent( PowerBroadcastStatus powerStatus) { log.Debug(m => m("Handling power event '{0}' on service '{1}'...", powerStatus, ServiceName)); bool returnValue = false; if (serviceInstance.CanHandlePowerEvent) { returnValue = serviceInstance.OnPowerEvent(powerStatus); } log.Debug(m => m("Done handling power event '{0}' on service '{1}'.", powerStatus, ServiceName)); return(returnValue); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { switch(powerStatus) { case PowerBroadcastStatus.Suspend: logger.Trace("OnPowerEvent: Computer suspend"); logSend("Suspend"); break; case PowerBroadcastStatus.ResumeSuspend: logger.Trace("OnPowerEvent: Computer resume"); logSend("Resume"); break; } return base.OnPowerEvent(powerStatus); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (powerStatus == PowerBroadcastStatus.Suspend || powerStatus == PowerBroadcastStatus.QuerySuspend) { if (node != null) node.Stop(); node = null; } else if (powerStatus == PowerBroadcastStatus.ResumeSuspend || powerStatus == PowerBroadcastStatus.ResumeCritical || powerStatus == PowerBroadcastStatus.ResumeAutomatic || powerStatus == PowerBroadcastStatus.QuerySuspendFailed) { if (node == null) node = new ComputerNode(); node.Start(); } return true; }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { debuglog.Info("OnPowerEvent:" + powerStatus.ToString()); switch (powerStatus) { case PowerBroadcastStatus.ResumeAutomatic: case PowerBroadcastStatus.ResumeCritical: case PowerBroadcastStatus.ResumeSuspend: debuglog.Info("RELOGIN "); runningFlag = 1; thr.Join(); OnStart(new string[] { }); return true; } return base.OnPowerEvent(powerStatus); }
/// <summary> /// When implemented in a derived class, executes when the computer's power status has changed. This applies to laptop computers when they go into suspended mode, which is not the same as a system shutdown. /// </summary> /// <param name="powerStatus">A <see cref="T:System.ServiceProcess.PowerBroadcastStatus"/> that indicates a notification from the system about its power status.</param> /// <returns> /// When implemented in a derived class, the needs of your application determine what value to return. For example, if a QuerySuspend broadcast status is passed, you could cause your application to reject the query by returning false. /// </returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { return true; }
/// <summary> /// Handle power events, such as hibernation. /// </summary> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if (imapProxies != null) { foreach (ImapProxy imapProxy in imapProxies) imapProxy.ProcessPowerEvent((int)powerStatus); imapProxies.Clear(); } if (pop3Proxies != null) { foreach (Pop3Proxy pop3Proxy in pop3Proxies) pop3Proxy.ProcessPowerEvent((int)powerStatus); pop3Proxies.Clear(); } if (smtpProxies != null) { foreach (SmtpProxy smtpProxy in smtpProxies) smtpProxy.ProcessPowerEvent((int)powerStatus); smtpProxies.Clear(); } return base.OnPowerEvent(powerStatus); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { _logger.WriteEntry("OnPowerEvent", EventLogEntryType.Information); return base.OnPowerEvent(powerStatus); }
public WindowsPowerEventArguments(PowerBroadcastStatus powerStatus) { _eventCode = (PowerEventCode) Enum.ToObject(typeof(PowerEventCode), (int)powerStatus); }
protected void SendSystemStatePowerMessage(PowerBroadcastStatus status) { switch (status) { case PowerBroadcastStatus.ResumeAutomatic: case PowerBroadcastStatus.ResumeCritical: case PowerBroadcastStatus.ResumeSuspend: SystemMessaging.SendSystemStateChangeMessage(SystemState.Resuming); break; case PowerBroadcastStatus.Suspend: SystemMessaging.SendSystemStateChangeMessage(SystemState.Suspending); break; } }
/// <summary> /// When implemented in a derived class, executes when the computer's power status has changed. This applies to laptop computers when they go into suspended mode, which is not the same as a system shutdown. /// </summary> /// <param name="powerStatus">A <see cref="T:System.ServiceProcess.PowerBroadcastStatus"/> that indicates a notification from the system about its power status.</param> /// <returns> /// When implemented in a derived class, the needs of your application determine what value to return. For example, if a QuerySuspend broadcast status is passed, you could cause your application to reject the query by returning false. /// </returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { bool status = false; try { switch (powerStatus) { case PowerBroadcastStatus.QuerySuspend: status = base.OnPowerEvent(powerStatus); break; case PowerBroadcastStatus.ResumeSuspend: this.OnStart(null); status = base.OnPowerEvent(powerStatus); break; case PowerBroadcastStatus.Suspend: this.OnStop(); status = base.OnPowerEvent(powerStatus); break; } } catch (Exception e) { Log.Error(e); status = false; } Log.Info(string.Format("Responding {0} to {1} request", status, powerStatus)); return status; }
/// <summary> /// Override of the Power Event /// </summary> /// <param name="powerStatus"></param> /// <returns></returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { if ((powerStatus == PowerBroadcastStatus.BatteryLow) | (powerStatus == PowerBroadcastStatus.Suspend)) { // stop the background processing StopProcesses(); } if ((powerStatus == PowerBroadcastStatus.ResumeAutomatic) | (powerStatus == PowerBroadcastStatus.ResumeCritical) | (powerStatus == PowerBroadcastStatus.ResumeSuspend)) { // start the background processing StartProcesses(); } return base.OnPowerEvent(powerStatus); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { try { LogMessage("Received power event: " + powerStatus, LogEntryType.StatusChange); switch (powerStatus) { case PowerBroadcastStatus.QuerySuspend: ExecutionManager.StopService(false); break; case PowerBroadcastStatus.Suspend: ExecutionManager.StopService(false); break; case PowerBroadcastStatus.ResumeAutomatic: if (ExecutionManager.ExecutionState != ExecutionState.Running) ExecutionManager.StartService(this); break; case PowerBroadcastStatus.ResumeSuspend: case PowerBroadcastStatus.ResumeCritical: case PowerBroadcastStatus.QuerySuspendFailed: if (ExecutionManager.ExecutionState != ExecutionState.Running) ExecutionManager.StartService(this); break; }; return true; } catch (Exception e) { LogMessage("OnPowerEvent - Exception: " + e.Message, LogEntryType.ErrorMessage); throw e; } }
/// <summary> /// OnPowerEvent(): Useful for detecting power status changes, /// such as going into Suspend mode or Low Battery for laptops. /// </summary> /// <param name="power_status">The Power Broadcast Status /// (BatteryLow, Suspend, etc.)</param> protected override bool OnPowerEvent(PowerBroadcastStatus power_status) { _log.Info("Service power event detected = {0}.", power_status.ToString()); _log.Flush(); if (power_status == PowerBroadcastStatus.Suspend) { _collector.Stop(); } return base.OnPowerEvent(power_status); }
/// <summary> /// This occurs when a power event was triggered. /// </summary> /// <param name="powerStatus">Indicates the system's power status</param> /// <returns>True if we are going to accept the query, otherwise false</returns> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { try { Trace.WriteLine("On Power Event"); Trace.WriteLine(powerStatus.ToString()); } catch (Exception ex) { Trace.WriteLine(ex); } //When implemented in a derived class, the needs of your application determine what value to return. //For example, if a QuerySuspend broadcast status is passed, you could cause your application to //reject the query by returning false. return base.OnPowerEvent(powerStatus); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { return ((IServiceEvents)this).OnPowerEvent(powerStatus); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { using (var eventLog = new TaskManagementEventLog()) { try { Trace.WriteLineIf(Tracing.Is.TraceVerbose, "powerStatus={0}".FormatWith(powerStatus.ToString("G"))); switch (powerStatus) { case PowerBroadcastStatus.QuerySuspend: OnPause(); break; case PowerBroadcastStatus.Suspend: OnStop(); break; case PowerBroadcastStatus.QuerySuspendFailed: case PowerBroadcastStatus.ResumeAutomatic: case PowerBroadcastStatus.ResumeCritical: case PowerBroadcastStatus.ResumeSuspend: if (null == Manager) { OnStart(Args); } else { OnContinue(); } break; } } catch (Exception exception) { eventLog.FailureOnPowerEvent(powerStatus); Trace.TraceError("{0}", exception); } } return false; }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { // Save all session/other data? return base.OnPowerEvent(powerStatus); }
bool IServiceEvents.OnPowerEvent(PowerBroadcastStatus powerStatus) { return base.OnPowerEvent(powerStatus); }
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { Log.Info("Power status updated."); Log.DebugFormat("Status: {0}", powerStatus); return base.OnPowerEvent(powerStatus) && ProviderLoader.Provider.PowerEvent(powerStatus); }
public void FailureOnPowerEvent(PowerBroadcastStatus powerStatus) { WriteEvent(new EventInstance(0xC00003F9, 2, EventLogEntryType.Error), powerStatus.ToString("G")); }
public void SuccessOnPowerEvent(PowerBroadcastStatus powerStatus) { WriteEvent(new EventInstance(0x000003EF, 2), powerStatus.ToString("G")); }
/// <summary> /// /// </summary> /// <param name="status"></param> public PowerBroardCastEventArgs(PowerBroadcastStatus status) { Status = status; }
/// <summary> /// OnPowerEvent(): Useful for detecting power status changes, /// such as going into Suspend mode or Low Battery for laptops. /// </summary> /// <param name="powerStatus">The Power Broadcase Status (BatteryLow, Suspend, etc.)</param> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { return base.OnPowerEvent(powerStatus); }
protected virtual bool OnPowerEvent(PowerBroadcastStatus powerStatus) { return true; }
/// <summary> /// OnPowerEvent(): Useful for detecting power status changes, /// such as going into Suspend mode or Low Battery for laptops. /// </summary> /// <param name="powerStatus">The Power Broadcast Status /// (BatteryLow, Suspend, etc.)</param> protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { Log("Power Status Changed", true); return base.OnPowerEvent(powerStatus); }