/// <summary> /// Creates a new <see cref="IHub"/> instance. /// </summary> /// <param name="channelListener">The channel listener.</param> /// <returns>A new <see cref="IHub"/> instance.</returns> /// <exception cref="System.ArgumentNullException">Thrown when the channel listener is null.</exception> public static IHub Create(IChannelListener channelListener) { Contract.Requires <ArgumentNullException>(channelListener != null, "channelListener"); Contract.Ensures(Contract.Result <IHub>() != null); return(new Hub(DeviceListener.Create(channelListener))); }
public void StartListening() { TrezorDevice?.Dispose(); DeviceListener = new DeviceListener(_deviceDefinitions, 3000); DeviceListener.DeviceDisconnected += DevicePoller_DeviceDisconnected; DeviceListener.DeviceInitialized += DevicePoller_DeviceInitialized; }
public Reader() { DeviceListener = new DeviceListener(_DeviceDefinitions, PollMilliseconds) { Logger = new DebugLogger() }; }
public void start() { deviceListener = new DeviceListener(); deviceListener.connected += new ConnectDeviceEventHandler(connected); deviceListener.disconnected += new DisconnectDeviceEventHandler(disconnected); deviceListener.startListening(); }
private void NotifyListeners_Update() { foreach (SceneListener listener in sceneListeners) { listener.SceneUpdated(scene); } foreach (KeyValuePair <ActorListener, Actor> entry in actorListeners) { // which actor is that? ActorListener listener = entry.Key; Actor actor = entry.Value; if (actor != null) { listener.ActorUpdated(actor); } } foreach (KeyValuePair <DeviceListener, Device> entry in deviceListeners) { // which device is that? DeviceListener listener = entry.Key; Device device = entry.Value; if (device != null) { listener.DeviceUpdated(device); } } }
public void EventReceived_EmgData_DoesNotTriggerPairedEvent() { // Setup var channel = new Mock <IChannelListener>(); var deviceListener = DeviceListener.Create(channel.Object); var gotPairedEvent = false; deviceListener.Paired += (_, __) => gotPairedEvent = true; var routeEventArgs = new RouteMyoEventArgs( new IntPtr(123), new IntPtr(123), MyoEventType.Emg, DateTime.UtcNow); // Execute channel.Raise(x => x.EventReceived += null, routeEventArgs); // Assert Assert.False( gotPairedEvent, "Not expecting to get the paired event."); }
private async Task <bool> ListenForDeviceAsync() { var listenTaskCompletionSource = new TaskCompletionSource <bool>(); var deviceListener = new DeviceListener(new List <FilterDeviceDefinition> { new FilterDeviceDefinition { VendorId = MockHidDevice.VendorId, ProductId = MockHidDevice.ProductId } }, 1000); deviceListener.DeviceInitialized += (a, deviceEventArgs) => { Console.WriteLine($"{deviceEventArgs.Device?.DeviceId} connected"); listenTaskCompletionSource.SetResult(true); }; deviceListener.Start(); var listenTask = listenTaskCompletionSource.Task; var timeoutTask = SimulateTimeoutAsync(listenTask, 3); var completedTask = await Task.WhenAny(new List <Task> { listenTask, timeoutTask }); return(ReferenceEquals(completedTask, timeoutTask)); }
public DeviceService(IInternalDXDeviceService deviceService) { FDeviceService = deviceService; FDeviceListener = new DeviceListener(this); FDeviceService.Subscribe(FDeviceListener); UseDx9Ex = deviceService.UseDx9Ex; }
public MicrosoftDock() { DeviceListener = new DeviceListener(_DeviceDefinitions, PollMilliseconds) { Logger = new DebugLogger() }; }
public void EventReceived_Paired_TriggersPairedEvent() { // Setup var channel = new Mock <IChannelListener>(); var deviceListener = DeviceListener.Create(channel.Object); PairedEventArgs actualEventArgs = null; deviceListener.Paired += (_, args) => actualEventArgs = args; var myoHandle = new IntPtr(12345); var timestamp = DateTime.UtcNow; var routeEventArgs = new RouteMyoEventArgs( myoHandle, new IntPtr(123), MyoEventType.Paired, timestamp); // Execute channel.Raise(x => x.EventReceived += null, routeEventArgs); // Assert Assert.NotNull(actualEventArgs); Assert.Equal(myoHandle, actualEventArgs.MyoHandle); Assert.Equal(timestamp, actualEventArgs.Timestamp); }
public TrezorExample() { DeviceListener = new DeviceListener(_DeviceDefinitions, PollMilliseconds) { Logger = new DebugLogger() }; }
public void StartListening() { TrezorDevice?.Dispose(); DeviceListener = new DeviceListener(_DeviceDefinitions, PollMilliseconds); DeviceListener.DeviceDisconnected += DevicePoller_DeviceDisconnected; DeviceListener.DeviceInitialized += DevicePoller_DeviceInitialized; DeviceListener.Start(); }
public MainWindow() { InitializeComponent(); this.device = new DeviceListener(); device.KeyboardKeyDown += this.Device_KeyboardKeyDown; device.StartListen(); }
private void button1_Click(object sender, EventArgs e) { deviceListener = new DeviceListener(this, int.Parse(textBox1.Text), textBox2.Text, textBox3.Text); deviceListener.EventLogin += new DeviceListener.LoginHandler(EventLogin); deviceListener.EventLogout += new DeviceListener.LoginHandler(EventLogout); button1.Enabled = false; }
public Footpedal() { WindowsUsbDeviceFactory.Register(_debugLogger, _debugTracer); WindowsHidDeviceFactory.Register(_debugLogger, _debugTracer); _deviceListener = new DeviceListener(_DeviceDefinitions, PollMilliseconds) { Logger = _debugLogger }; }
private TEMPerSensors(ILogger?logger) { _deviceListener = new DeviceListener(_deviceDefinitions, PollMilliseconds) { Logger = logger }; _deviceListener.DeviceInitialized += DeviceInitializedHandler; _deviceListener.DeviceDisconnected += DeviceDisconnectedHandler; }
public MainPage() { InitializeComponent(); _tokenSource = new CancellationTokenSource(); _listener = new DeviceListener( brick: new Brick(new CommunicationFactory(), new FileProvider()), notify: NotifyMethodAsync ); }
public void Create_ValidParameters_NewInstance() { // Setup var channel = new Mock <IChannelListener>(); // Execute var result = DeviceListener.Create(channel.Object); // Assert Assert.NotNull(result); }
public static void Main(string[] args) { DeviceListener deviceListener = new DeviceListener(); deviceListener.StartListen(); deviceListener.MouseAction += OnMouseAction; deviceListener.KeyboardAction += OnKeyboardAction; Console.ReadLine(); deviceListener.StopListen(); }
public void InitializeConnector() { DeviceMessage = new DeviceListener(); SourceInitialized += DeviceMessage.RegisterListener; Serialcon = new SerialConnector { Mw = this }; Serialcon.Event += new ConnectorHandler(ConnectorCallBack); DeviceMessage.Event += Serialcon.SerialChangedEvent; }
public void GetChannelListener_ValidState_SameInstanceAsConstructor() { // Setup var channel = new Mock <IChannelListener>(); var deviceListener = DeviceListener.Create(channel.Object); // Execute var result = deviceListener.ChannelListener; // Assert Assert.Equal(channel.Object, result); }
public void Create_NullChannelListener_ThrowsNullArgumentException() { // Setup // Execute Assert.ThrowsDelegate method = () => DeviceListener.Create(null); // Assert var exception = Assert.Throws <ArgumentNullException>(method); Assert.Equal("channelListener", exception.ParamName); }
private static void Main() { var listener = new DeviceListener(); listener.DeviceInformationReceived += (_, args) => { Console.WriteLine($"{args.Reason}: device {args.Device.Name} (ID {args.Device.Id})"); }; listener.StartListening(); Console.WriteLine("Press any key to exit"); Console.ReadKey(); }
/// <summary> /// Adds a device data listener. /// </summary> /// <param name="listener">The listener to add</param> /// <returns><c>true</c>, if the device listener was added, <c>false</c> otherwise.</returns> /// public bool AddDeviceListener(DeviceListener listener) { bool added = false; if (!deviceListeners.ContainsKey(listener)) { Device device = scene.FindDevice(listener.GetDeviceName()); deviceListeners.Add(listener, device); added = true; // immediately trigger callback listener.DeviceChanged(device); } return(added); }
/// <summary> /// Placeholder. This currently does nothing but you should call this to initialize listening /// </summary> public void Start() { if (_DeviceListener != null) { return; } _DeviceListener = new DeviceListener(DeviceDefinitions, PollInterval); _DeviceListener.DeviceDisconnected += DevicePoller_DeviceDisconnected; _DeviceListener.DeviceInitialized += DevicePoller_DeviceInitialized; _DeviceListener.Start(); //TODO: Call Start on the DeviceListener when it is implemented... }
public async void Run(IBackgroundTaskInstance taskInstance) { _deferral = taskInstance.GetDeferral(); taskInstance.Canceled += OnTaskCanceled; _source = new CancellationTokenSource(); _listener = new DeviceListener( brick: new Brick(new CommunicationFactory(), new FileProvider()), notify: NotifyMethodAsync ); await ThreadPool.RunAsync(async _ => { await _listener.ConnectAsync(_source.Token); await _listener.InitializeAsync(); }); }
protected TrezorManagerBrokerBase( EnterPinArgs enterPinArgs, EnterPinArgs enterPassphraseArgs, int?pollInterval, IDeviceFactory deviceFactory, ICoinUtility coinUtility = null, ILoggerFactory loggerFactory = null) { EnterPinArgs = enterPinArgs; EnterPassphraseArgs = enterPassphraseArgs; CoinUtility = coinUtility ?? new DefaultCoinUtility(); PollInterval = pollInterval; LoggerFactory = loggerFactory; _DeviceListener = new DeviceListener(deviceFactory, PollInterval, loggerFactory); _DeviceListener.DeviceDisconnected += DevicePoller_DeviceDisconnected; _DeviceListener.DeviceInitialized += DevicePoller_DeviceInitialized; }
public void TestListenerDeviceFactoriesNotRegisteredException() { DeviceManager.Current.DeviceFactories.Clear(); try { var deviceListner = new DeviceListener(new List <FilterDeviceDefinition>(), 1000); deviceListner.Start(); } catch (DeviceFactoriesNotRegisteredException) { return; } finally { Startup(); } throw new Exception("The call was not stopped"); }
public override async Task LoadDevicesAsync() { var legacyHid = new FilterDeviceDefinition(vendorId: LOGITECH_VENDOR_ID, usagePage: 0xFF00) .CreateWindowsHidDeviceFactory(); var modernHid = new FilterDeviceDefinition(vendorId: LOGITECH_VENDOR_ID, usagePage: 0xFF43) .CreateWindowsHidDeviceFactory(); var factories = legacyHid.Aggregate(modernHid); var deviceDefinitions = (await factories.GetConnectedDeviceDefinitionsAsync().ConfigureAwait(false)).ToList(); _LogiDevices.Clear(); _deviceListener?.Dispose(); _deviceListener = new DeviceListener(factories, 1000, null); _deviceListener.DeviceInitialized += _deviceListener_DeviceInitialized; _deviceListener.DeviceDisconnected += _deviceListener_DeviceDisconnected; _deviceListener.Start(); }
public static void Main(string[] args) { try { AppKit.NSApplication.Init(); var devices = UsbMux.ListDevices(); foreach (var d in devices) { try { Console.WriteLine(string.Format("device: {0}", d.DeviceID)); var stream = UsbMux.Connect(d, 1337); var streamReader = new StreamReader(stream); var hello = streamReader.ReadLine(); Console.WriteLine("phone says: {0}", hello); var streamWriter = new StreamWriter(stream); streamWriter.WriteLine("HELLO TO YOU TOO, PHONE!\n"); streamWriter.Flush(); } catch (FailedToConnectToDevice e) { Console.WriteLine("failed to connect to device: {0}", e.ToString()); } } var deviceListener = new DeviceListener(); deviceListener.DeviceAttached += (object sender, DeviceListener.DeviceEventArgs a) => Console.WriteLine("attached: " + a.Device.ToString()); deviceListener.DeviceDetached += (object sender, DeviceListener.DeviceEventArgs a) => Console.WriteLine("detached: " + a.Device.ToString()); while (true) { deviceListener.Poll(); } } catch (Exception e) { Console.WriteLine("fatal exception: {0}", e.ToString()); } }
/// <summary> /// Start listening to the movements. /// </summary> public LeapMotionManager() { controller = new Controller(); listener = new DeviceListener(); controller.AddListener(listener); }