public void CleanUp_ForNotExpiredDeviceInCollection_DoesNotNotifyDeviceExpired( ILogger logger, IDateTimeOffset dateTimeOffset, IDeviceMonitor deviceMonitor, ISubject <IDevice> deviceExpired, ObservableTimerFactory factory, TestScheduler scheduler, IDevice device) { deviceMonitor.DiscoveredDevices .Returns(new[] { device }); var sut = new DeviceMonitorWithExpiry(logger, dateTimeOffset, deviceMonitor, deviceExpired, factory, scheduler); dateTimeOffset.Ticks .Returns(sut.TimeOut.Ticks); dateTimeOffset.Now .Returns(dateTimeOffset); device.BroadcastTime .Ticks .Returns(sut.TimeOut.Ticks / 2); scheduler.AdvanceBy(sut.TimeOut.Ticks); deviceExpired.DidNotReceive() .Publish(device); }
public void CleanUp_ForOneExpiredDeviceInCollection_RemovesDeviceFromCollection( ILogger logger, IDateTimeOffset dateTimeOffset, IDeviceMonitor deviceMonitor, ISubject <IDevice> deviceExpired, ObservableTimerFactory factory, TestScheduler scheduler, IDevice device) { deviceMonitor.DiscoveredDevices .Returns(new[] { device }); var sut = new DeviceMonitorWithExpiry(logger, dateTimeOffset, deviceMonitor, deviceExpired, factory, scheduler); dateTimeOffset.Ticks .Returns(sut.TimeOut.Ticks); dateTimeOffset.Now .Returns(dateTimeOffset); device.BroadcastTime .Ticks .Returns(0); scheduler.AdvanceBy(sut.TimeOut.Ticks + 1); deviceMonitor.Received() .RemoveDevice(device); }
public DeviceMonitorWithExpiry( [NotNull] ILogger logger, [NotNull] IDateTimeOffset dateTimeOffset, [NotNull] IDeviceMonitor deviceMonitor, [NotNull] ISubject <IDevice> deviceExpired, [NotNull] IObservableTimerFactory factory, [NotNull] IScheduler scheduler) { Guard.ArgumentNotNull(logger, nameof(logger)); Guard.ArgumentNotNull(dateTimeOffset, nameof(dateTimeOffset)); Guard.ArgumentNotNull(deviceMonitor, nameof(deviceMonitor)); Guard.ArgumentNotNull(deviceExpired, nameof(deviceExpired)); Guard.ArgumentNotNull(factory, nameof(factory)); Guard.ArgumentNotNull(scheduler, nameof(scheduler)); _logger = logger; _dateTimeOffset = dateTimeOffset; _deviceMonitor = deviceMonitor; _deviceExpired = deviceExpired; _timer = factory.Create(TimeOut, scheduler) .SubscribeOn(scheduler) .Subscribe(CleanUp, OnError, OnCompleted); }
public void CleanUp_ForOneExpiredDeviceInCollection_NotifiesDeviceExpired( ILogger logger, IDateTimeOffset dateTimeOffset, IDeviceMonitor deviceMonitor, Subject <IDevice> deviceExpired, ObservableTimerFactory factory, TestScheduler scheduler, IDevice device) { var sut = new DeviceMonitorWithExpiry(logger, dateTimeOffset, deviceMonitor, deviceExpired, factory, scheduler); IDevice expiredDevice = null; using var disposable = sut.DeviceExpired .Subscribe(expired => expiredDevice = expired); deviceExpired.OnNext(device); scheduler.AdvanceBy(sut.TimeOut.Ticks); expiredDevice.Should() .Be(device); }
protected override void EstablishContext() { A.CallTo(() => _contextFactory.Establish(SCardScope.System)) .Returns(_context); A.CallTo(() => _context.IsValid()) .Returns(true); A.CallTo(() => _context.Infinite) .Returns(SCardContext.INFINITE); // first call -> only one attached reader A.CallTo(() => _context.GetReaders()) .Returns(new[] { READER_A }); A.CallTo(() => _context.GetStatusChange(SCardContext.INFINITE, A <SCardReaderState[]> .That.Matches( states => MatchFirstCall(states)))) .ReturnsLazily(call => { // second call -> two attached readers A.CallTo(() => _context.GetReaders()) .Returns(new[] { READER_A, READER_B }); _getStatusChangeCall.Set(); return(SCardError.Success); }); A.CallTo(() => _context.GetStatusChange(SCardContext.INFINITE, A <SCardReaderState[]> .That.Matches( states => MatchSecondCall(states)))) .Returns(SCardError.Cancelled); _sut = new DeviceMonitor(_contextFactory, SCardScope.System); _monitorEvents = _sut.MonitorEvents(); }
/// <summary> /// Releases the smartcard device monitor and its dependencies using the <see cref="IDisposable.Dispose"/> method. /// </summary> /// <param name="monitor">Smartcard device monitor that shall be stopped and disposed.</param> public void Release(IDeviceMonitor monitor) { if (monitor == null) { throw new ArgumentNullException(nameof(monitor)); } monitor.Dispose(); }
public DevicesViewModel(IAdbClient adbClient, IDeviceMonitor deviceMonitor) { _deviceMontior = deviceMonitor; _adbClient = adbClient; UpdateConnectedDevices(); _deviceMontior.DeviceConnected += OnDeviceConnected; _deviceMontior.DeviceDisconnected += OnDeviceDisconnected; }
/// <summary> /// /// </summary> protected void EnableDevicesMonitor() { deviceMonitor = DeviceMonitorFactory.Instance.Create(SCardScope.System); deviceMonitor.Initialized += OnDevicesInitialized; deviceMonitor.StatusChanged += OnDevicesStatusChanged; deviceMonitor.MonitorException += OnDevicesMonitorException; deviceMonitor.Start(); }
public void Dispose_ForInvoked_DisposesMonitor( DeviceMonitorWithExpiry sut, [Freeze] IDeviceMonitor monitor) { sut.Dispose(); monitor.Received() .Dispose(); }
public void Stop_ForInvoked_CallsDeviceMonitor( DeviceMonitorWithExpiry sut, [Freeze] IDeviceMonitor monitor) { sut.Stop(); monitor.Received() .Stop(); }
public void RemoveDevice_ForInvoked_CallsDeviceMonitor( DeviceMonitorWithExpiry sut, [Freeze] IDeviceMonitor monitor, IDevice device) { sut.RemoveDevice(device); monitor.Received() .RemoveDevice(device); }
static void Main(string[] args) { Console.WriteLine("m = Start monitor"); Console.WriteLine("e = Start monitor with exception"); Console.WriteLine("s = Stop current monitor"); Console.WriteLine("q = Quit program"); ConsoleKeyInfo key = default(ConsoleKeyInfo); while (key.KeyChar != 'q') { key = Console.ReadKey(); if (key.KeyChar == 'm') { if (monitor == null || currentStatus == MonitorStatus.STOPPED) { Console.WriteLine("Starting monitor with refresh interval of 2 seconds"); monitor = new TimerMonitor(); monitor.DataReceived += new EventHandler<DataReceivedEventArgs<DateTime>>(monitor_DataReceived); monitor.MonitorStatusChanged += new EventHandler<MonitorStatusEventArgs>(monitor_MonitorStatusChanged); monitor.Start(2000); } } if (key.KeyChar == 'e') { if (monitor == null || currentStatus == MonitorStatus.STOPPED) { Console.WriteLine("Starting monitor with exception occuring on the 20th second"); monitor = new TimerMonitorWithException(); monitor.MonitorStatusChanged += new EventHandler<MonitorStatusEventArgs>(monitor_MonitorStatusChanged); monitor.DataReceived += new EventHandler<DataReceivedEventArgs<DateTime>>(monitor_DataReceived); monitor.Start(20); } } if (key.KeyChar == 's') { if (monitor != null && currentStatus == MonitorStatus.STARTED) { monitor.Stop(); } } } if (monitor != null && currentStatus == MonitorStatus.STARTED) { monitor.Stop(); monitor.Dispose(); } }
public void IsListening_ForInvoked_CallsDeviceMonitor( DeviceMonitorWithExpiry sut, [Freeze] IDeviceMonitor monitor) { monitor.IsListening .Returns(true); sut.IsListening .Should() .BeTrue(); }
public void DiscoveredDevices_ForInvoked_CallsDeviceMonitor( DeviceMonitorWithExpiry sut, [Freeze] IDeviceMonitor monitor, IReadOnlyCollection <IDevice> collection) { monitor.DiscoveredDevices .Returns(collection); sut.DiscoveredDevices .Should() .BeEquivalentTo(collection); }
public void DeviceNameUpdated_ForInvoked_CallsDeviceMonitor( DeviceMonitorWithExpiry sut, [Freeze] IDeviceMonitor monitor, IObservable <IDevice> observable) { monitor.DeviceNameUpdated .Returns(observable); sut.DeviceNameUpdated .Should() .Be(observable); }
public void DeviceUpdated( IDeviceMonitor monitor, IList<DevicePropertyChange> deviceChanges, IList<LinePropertyChange> lineChanges, IList<CallPropertyChange> callChanges) { // FIXME this is very inefficient List<PropertyChange> changes = new List<PropertyChange>(); foreach( PropertyChange change in deviceChanges ) changes.Add( change ); foreach( PropertyChange change in lineChanges ) changes.Add( change ); foreach( PropertyChange change in callChanges ) changes.Add( change ); foreach( PropertyChange change in changes ) // Note that we log changing to or from any given logging criteria if( LookupPropertyChangeBehaviour( change.Underlying, change.Property, change.ChangedTo ).Log || LookupPropertyChangeBehaviour( change.Underlying, change.Property, change.ChangedFrom ).Log ) Logger.Instance().Log( change.Underlying.GetType().Name + " property " + change.Property + " has changed from " + change.ChangedFrom + " to " + change.ChangedTo ); // Logging happens here: foreach( CallPropertyChange change in callChanges ) { if( change.Property == DeviceMonitor.PROPERTY_CALL_ACTIVITY ) { if ( change.ChangedTo == Activity.Connected.ToString() ) { CallRecord call = new CallRecord( monitor.GetDeviceState(), GetLine( change.Call ), change.Call, DateTime.Now, new DateTime() ); // Sanity check in case somehow call is already there if ( mCalls.ContainsKey( change.Call ) ) { mCalls.Remove( change.Call ); Logger.Instance().Log("Call #" + change.Call.Name + " had to be removed from the call list - did the previous call fail?"); } mCalls.Add( change.Call, call ); } else if ( change.ChangedFrom == Activity.Connected.ToString() ) { CallRecord call = mCalls[change.Call]; call.EndTime = DateTime.Now; CallLogger.Instance().Log(call); mCalls.Remove( change.Call ); } } if (change.Call.Activity != Activity.IdleDisconnected) { if ( mCalls.ContainsKey( change.Call ) ) { CallRecord call = mCalls[change.Call]; call.Call = change.Call; call.Line = GetLine(change.Call); mCalls[change.Call] = call; } } } if( StateUpdate != null ) StateUpdate( monitor, new StateUpdateEventArgs( deviceChanges, lineChanges, callChanges ) ); }
public void Constructor_ForDateTimeOffsetNull_Throws( Lazy <DeviceMonitorWithExpiry> sut, [BeNull] IDeviceMonitor deviceMonitor) { // ReSharper disable once UnusedVariable Action action = () => { var test = sut.Value; }; action.Should() .Throw <ArgumentNullException>() .WithParameter(nameof(deviceMonitor)); }
/// <summary> /// Listen to all device events of a given <see cref="IDeviceMonitor"/>. /// </summary> /// <param name="monitor">The device monitor to listen on.</param> /// <param name="scheduler">The scheduler to run the add and remove event handler logic on.</param> /// <returns>An observable of reader attached/detached events.</returns> public static IObservable <DeviceMonitorEvent> ObserveEvents(this IDeviceMonitor monitor, IScheduler scheduler = null) { if (monitor == null) { throw new ArgumentNullException(nameof(monitor)); } var useScheduler = scheduler ?? Scheduler.ForCurrentContext(); var initialized = Observable.FromEventPattern <DeviceChangeEvent, DeviceChangeEventArgs>( handler => monitor.Initialized += handler, handler => monitor.Initialized -= handler, useScheduler) .Select(ev => ev.EventArgs) .Select(args => new DeviceMonitorInitialized(args)); var statusChanged = Observable.FromEventPattern <DeviceChangeEvent, DeviceChangeEventArgs>( handler => monitor.StatusChanged += handler, handler => monitor.StatusChanged -= handler, useScheduler) .Select(ev => ev.EventArgs) .SelectMany(CreateEvents); var monitorException = Observable .FromEventPattern <DeviceMonitorExceptionEvent, DeviceMonitorExceptionEventArgs>( handler => monitor.MonitorException += handler, handler => monitor.MonitorException -= handler, useScheduler) .Select(ev => ev.EventArgs); var monitorEvents = initialized .Cast <DeviceMonitorEvent>() .Merge(statusChanged); return(Observable.Create <DeviceMonitorEvent>(obs => { var subscription = monitorEvents.Subscribe(obs); var exceptionSubscription = monitorException .Take(1) .Subscribe(args => { subscription.Dispose(); obs.OnError(args.Exception); }); return new CompositeDisposable( subscription, exceptionSubscription); })); }
public Pcsc() { using (var context = ContextFactory.Instance.Establish(SCardScope.System)) { var readers = context.GetReaders(); Debug.WriteLine($"NUM READERS: {readers.Count()}"); foreach (var reader in readers) { Debug.WriteLine($"READER: {reader}"); } UpdateReaders(readers.ToList()); } _readersMonitor = DeviceMonitorFactory.Instance.Create(SCardScope.System); _readersMonitor.StatusChanged += OnReadersStatusChanged; _readersMonitor.Start(); }
static void Main(string[] args) { Console.WriteLine("m = Start monitor"); Console.WriteLine("s = Stop current monitor"); Console.WriteLine("q = Quit program"); ConsoleKeyInfo key = default(ConsoleKeyInfo); while (key.KeyChar != 'q') { key = Console.ReadKey(); if (key.KeyChar == 'm') { if (monitor == null || currentStatus == MonitorStatus.STOPPED) { Console.WriteLine("Starting monitor"); monitor = new TimerMonitor(); monitor.DataReceived += new EventHandler<DataReceivedEventArgs<DateTime>>(monitor_DataReceived); monitor.MonitorStatusChanged += new EventHandler<MonitorStatusEventArgs>(monitor_MonitorStatusChanged); monitor.Start(); } } if (key.KeyChar == 's') { if (monitor != null && currentStatus == MonitorStatus.STARTED) { monitor.Stop(); } } } if (monitor != null && currentStatus == MonitorStatus.STARTED) { monitor.Stop(); monitor.Dispose(); } }
public void OnError_ForInvoked_CallsStop( ILogger logger, IDateTimeOffset dateTimeOffset, IDeviceMonitor deviceMonitor, ISubject <IDevice> deviceExpired, IObservableTimerFactory factory, TestScheduler scheduler) { factory.Create(Arg.Any <TimeSpan>(), Arg.Any <IScheduler>()) .Returns(Observable.Throw <long>(new Exception())); var sut = new DeviceMonitorWithExpiry(logger, dateTimeOffset, deviceMonitor, deviceExpired, factory, scheduler); scheduler.AdvanceBy(sut.TimeOut.Ticks); deviceMonitor.Received() .Stop(); }
protected override void BecauseOf() { _monitor = _sut.Create(SCardScope.System); }
public DeviceMonitorControl( IDeviceMonitor monitor ) { mDeviceMonitor = monitor; }
public void StateManagerUpdated( IDeviceMonitor monitor, StateUpdateEventArgs e ) { // Iterate through state changes and deal with them as appropriate: List<String> externalProcesses = new List<String>(); StringBuilder bubbleTextBuilder = new StringBuilder(); bool showApplication = false; // FIXME this is very inefficient List<PropertyChange> changes = new List<PropertyChange>(); foreach( PropertyChange change in e.DeviceStateChanges ) changes.Add( change ); foreach( PropertyChange change in e.LineStateChanges ) changes.Add( change ); foreach( PropertyChange change in e.CallStateChanges ) changes.Add( change ); foreach( PropertyChange change in changes ) { PropertyChangeBehaviour behaviour = StateManager.Instance().LookupPropertyChangeBehaviour( change.Underlying, change.Property, change.ChangedTo ); if( behaviour.ShowBubble ) { if( bubbleTextBuilder.Length > 0 ) bubbleTextBuilder.AppendLine(); // Substitute in values from pattern. bubbleTextBuilder.Append( FormatString( behaviour.BubbleText, change.Property, change.ChangedFrom, change.ChangedTo ) ); } // Check to see if warning criteria is met. if( behaviour.SystemTrayWarning ) { // Activate warning state, if it isn't already: if( ! mWarnings.Contains( change.Underlying.GetHashCode() + ":" + change.Underlying.GetType().Name + ":" + change.Property ) ) mWarnings.Add( change.Underlying.GetHashCode() + ":" + change.Underlying.GetType().Name + ":" + change.Property ); } else { mWarnings.Remove( change.Underlying.GetHashCode() + ":" + change.Underlying.GetType().Name + ":" + change.Property ); } if( behaviour.ShowApplication ) showApplication = true; if( behaviour.ExternalProcess != "" ) externalProcesses.Add( FormatString( behaviour.ExternalProcess, change.Property, change.ChangedFrom, change.ChangedTo ) ); } TreeStates.Invoke( new MonitorPassingDelegate( UpdateTree ), new Object[] { changes } ); if( showApplication ) this.Invoke( new ShowFormDelegate( ShowFormMain ), new Object[] {} ); // Enable timer if there are warnings. this.Invoke( new SetTimer( SetTimerFlash ), new Object[] { mWarnings.Count > 0 } ); if( ! TimerFlash.Enabled ) NotifyIcon.Icon = global::LothianProductions.VoIP.Properties.Resources.HVoIPM_48x; foreach( String externalProcess in externalProcesses ) try { Process.Start( externalProcess ); } catch( Win32Exception ) { if( bubbleTextBuilder.Length > 0 ) bubbleTextBuilder.AppendLine(); bubbleTextBuilder.Append( "Failed to launch external process \"" + externalProcess + "\"" ); } if( bubbleTextBuilder.Length > 0 ) NotifyIcon.ShowBalloonTip( BUBBLE_TIMEOUT, monitor.Name + "'s state changed", bubbleTextBuilder.ToString(), ToolTipIcon.Info ); }
private void AddMonitorToTree( IDeviceMonitor monitor ) { // Use each node's key as a property name. Use each node's tag object as a state. Device deviceState = monitor.GetDeviceState(); TreeNode deviceNode = TreeStates.Nodes.Add( DeviceMonitor.PROPERTY_NAME, deviceState.Name ); deviceNode.Tag = deviceState; for( int i = 0; i < deviceState.Lines.Length; i++ ) { TreeNode lineNode = deviceNode.Nodes.Add( DeviceMonitor.PROPERTY_NAME, deviceState.Lines[ i ].Name ); lineNode.Tag = deviceState.Lines[ i ]; EnsureNodeContains( lineNode, deviceState.Lines[ i ], DeviceMonitor.PROPERTY_LINE_LASTCALLEDNUMBER, "", deviceState.Lines[ i ].LastCalledNumber ); EnsureNodeContains( lineNode, deviceState.Lines[ i ], DeviceMonitor.PROPERTY_LINE_LASTCALLERNUMBER, "", deviceState.Lines[ i ].LastCallerNumber ); EnsureNodeContains( lineNode, deviceState.Lines[ i ], DeviceMonitor.PROPERTY_LINE_MESSAGEWAITING, "", deviceState.Lines[ i ].MessageWaiting.ToString() ); EnsureNodeContains( lineNode, deviceState.Lines[ i ], DeviceMonitor.PROPERTY_LINE_REGISTRATIONSTATE, "", deviceState.Lines[ i ].RegistrationState.ToString() ); for( int j = 0; j < deviceState.Lines[ i ].Calls.Length; j++ ) { TreeNode callNode = lineNode.Nodes.Add( DeviceMonitor.PROPERTY_NAME, deviceState.Lines[ i ].Calls[ j ].Name ); callNode.Tag = deviceState.Lines[ i ].Calls[ j ]; EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_ACTIVITY, "", deviceState.Lines[ i ].Calls[ j ].Activity.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_BYTESRECEIVED, "", deviceState.Lines[ i ].Calls[ j ].BytesReceived.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_BYTESSENT, "", deviceState.Lines[ i ].Calls[ j ].BytesSent.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_DECODELATENCY, "", deviceState.Lines[ i ].Calls[ j ].DecodeLatency.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_DECODER, "", deviceState.Lines[ i ].Calls[ j ].Decoder ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_DURATION, "", deviceState.Lines[ i ].Calls[ j ].Duration ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_ENCODER, "", deviceState.Lines[ i ].Calls[ j ].Encoder ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_JITTER, "", deviceState.Lines[ i ].Calls[ j ].Jitter.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_PACKETERROR, "", deviceState.Lines[ i ].Calls[ j ].PacketError.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_PACKETLOSS, "", deviceState.Lines[ i ].Calls[ j ].PacketLoss.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_ROUNDTRIPDELAY, "", deviceState.Lines[ i ].Calls[ j ].RoundTripDelay.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_TONE, "", deviceState.Lines[ i ].Calls[ j ].Tone.ToString() ); EnsureNodeContains( callNode, deviceState.Lines[ i ].Calls[ j ], DeviceMonitor.PROPERTY_CALL_TYPE, "", deviceState.Lines[ i ].Calls[ j ].Type.ToString() ); } } deviceNode.ExpandAll(); }