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