public U2FHidKey([NotNull] IHidDevice device, bool closeDeviceOnDispose)
{
if (device == null) throw new ArgumentNullException(nameof(device));
this.device = device;
this.closeDeviceOnDispose = closeDeviceOnDispose;
}
public void CheckIn(ref IHidDevice HidDev)
{
((HidDevice)HidDev).StopDeviceReadThread();
((HidDevice)HidDev).DisposePreparsedData();
((HidDevice)HidDev).CloseFileHandle();
((HidDevice)HidDev).IsCheckedOut = false;
}
internal G933(IHidDevice device)
: base(device)
{
if(PId != Constants.LOGITECH_G933_PRODUCT_ID)
throw new Exception("Invalid Device");
if (VId != Constants.LOGITECH_VENDOR_ID)
throw new Exception("Invalid Device");
}
private static string GetManufacturerString(IHidDevice d)
{
if (d == null)
{
return("");
}
d.ReadManufacturer(out var bs);
return(System.Text.Encoding.Default.GetString(bs.Where(b => b > 0).ToArray()));
}
public U2FHidKey([NotNull] IHidDevice device, bool closeDeviceOnDispose)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
this.device = device;
this.closeDeviceOnDispose = closeDeviceOnDispose;
}
private static double GetTemperatureCelsius(IHidDevice bulk)
{
var report = WriteAndReadReport(bulk, 0x00, temperatureHumidityRaw);
var rawReading = (report.Data[3] & 0xFF) + (report.Data[2] << 8);
const double calibrationOffset = -1.70;
const double calibrationScale = 2.74301;
var temperatureCelsius = (calibrationScale * (rawReading * (125.0 / 32000.0))) + calibrationOffset;
return(temperatureCelsius);
}
public CycloneX10(IButtplugLogManager aLogManager, IHidDevice aHid, CycloneX10HidDeviceInfo aDeviceInfo)
: base(aLogManager, aHid, aDeviceInfo)
{
MsgFuncs.Add(typeof(VorzeA10CycloneCmd), new ButtplugDeviceWrapper(HandleVorzeA10CycloneCmd));
MsgFuncs.Add(typeof(RotateCmd), new ButtplugDeviceWrapper(HandleRotateCmd, new MessageAttributes()
{
FeatureCount = 1
}));
MsgFuncs.Add(typeof(StopDeviceCmd), new ButtplugDeviceWrapper(HandleStopDeviceCmd));
aHid.OpenDevice();
}
protected HidButtplugDevice(IButtplugLogManager aLogManager, IHidDevice aHid, IHidDeviceInfo aDeviceInfo)
: base(aLogManager, aDeviceInfo.Name, aHid.DevicePath)
{
LogManager = aLogManager;
_hid = aHid;
DeviceInfo = aDeviceInfo;
_tokenSource = new CancellationTokenSource();
_hid.Inserted += DeviceAttachedHandler;
_hid.Removed += DeviceRemovedHandler;
}
public CycloneX10(IButtplugLogManager aLogManager, IHidDevice aHid, CycloneX10HidDeviceInfo aDeviceInfo)
: base(aLogManager, aHid, aDeviceInfo)
{
AddMessageHandler <VorzeA10CycloneCmd>(HandleVorzeA10CycloneCmd);
AddMessageHandler <RotateCmd>(HandleRotateCmd, new MessageAttributes()
{
FeatureCount = 1
});
AddMessageHandler <StopDeviceCmd>(HandleStopDeviceCmd);
aHid.OpenDevice();
}
public Gamepad()
{
device = new HidEnumerator().Enumerate(VendorId, ProductId).First();
eventStream = Observable.Interval(TimeSpan.FromMilliseconds(100))
.Select(_ => ReadReport())
.DistinctUntilChanged(new HidReportComparer())
.Select(MapReport)
.Publish()
.RefCount();
}
public LedgerManager(IHidDevice ledgerHidDevice, ICoinUtility coinUtility)
{
LedgerHidDevice = ledgerHidDevice;
CoinUtility = coinUtility;
if (CoinUtility == null)
{
CoinUtility = new DefaultCoinUtility();
}
SetCoinNumber(0);
}
public static Task WriteReportAsync(this IHidDevice device, IHidReport report, CancellationToken token)
{
if (device == null)
{
throw new ArgumentNullException($"{nameof(device)} is null");
}
if (report == null)
{
throw new ArgumentNullException($"{nameof(report)} is null");
}
return(device.WriteRawDataAsync(report.GetWholeData(), token));
}
public static async IAsyncEnumerable <IHidReport> GetReadReportStreamAsync(this IHidDevice device, [EnumeratorCancellation] CancellationToken token = default)
{
if (device == null)
{
throw new ArgumentNullException($"{nameof(device)} is null");
}
while (!token.IsCancellationRequested)
{
yield return(await device.ReadReportAsync(token).ConfigureAwait(false));
}
}
private static Tuple <string, DeviceType> IdentityDevice(IHidDevice device)
{
device.ReadSerialNumber(out var output);
var chars = (from o in output where o != 0 select(char) o).ToArray();
var deviceType = DetermineDeviceType(output[0]);
var serialNumber = $"0x{string.Join(string.Empty, chars)}";
return(Tuple.Create(serialNumber, deviceType));
}
protected TrezorManagerBase(EnterPinArgs enterPinCallback, IHidDevice hidDevice)
{
if (hidDevice == null)
{
throw new ArgumentNullException(nameof(hidDevice));
}
hidDevice.Connected += HidDevice_Connected;
_EnterPinCallback = enterPinCallback;
_HidDevice = hidDevice;
}
public void InitKeyboard(Device p_Device, IHidDevice p_IHidDevice)
{
m_Device = p_Device;
m_HidDeviceEvents_HidDataReceivedEventHandler = new EventHandler <HidDataReceivedEventArgs>(HidDataReceived);
m_IHidDevice = p_IHidDevice;
m_IHidDevice.DataReceived += m_HidDeviceEvents_HidDataReceivedEventHandler;
m_Keys = 2;
m_ProgrammableKeys = 0;
#region Feature Report??
//////////////////////////////////////////////
// hier muss vom Aerion abgefragt werden, wieviele Tasten er hat
// und der InitKeyboard entsprechend aufgerufen werden.
// irgendwie so:
// HidReport m_HIDFeatureReport = p_IHidDevice.ReadFeatureReport();
/*
* try
* {
* byte[] buffer = {
* p_HidDataReceivedEventArgs[1],
* p_HidDataReceivedEventArgs[2],
* p_HidDataReceivedEventArgs[3],
* p_HidDataReceivedEventArgs[4],
* p_HidDataReceivedEventArgs[5],
* p_HidDataReceivedEventArgs[6],
* };
*
* System.IO.MemoryStream stream = new System.IO.MemoryStream(buffer, 0, buffer.Length);
* System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
*
* m_keys = Convert.ToInt64(reader.ReadInt16());
* bool status = reader.ReadBoolean();
*
* }
*
* catch (Exception e)
* {
* Console.Out.WriteLine("Exception: {0}", e.GetType());
* }
*/
#endregion
m_KeyDownList = new BitArray(8, false);
m_KeyNameList = new string[m_Keys];
m_KeyLabelList = new string[m_Keys];
m_KeyNameList[0] = "L";
m_KeyNameList[1] = "R";
m_KeyLabelList[0] = "L";
m_KeyLabelList[1] = "R";
}
public UsbDevice(IHidDevice device)
{
_device = device;
_device.Inserted += DeviceInsert;
_device.Removed += DeviceRemove;
_device.MonitorDeviceEvents = true;
if (device.IsConnected)
{
DeviceInsert();
}
}
internal G933(IHidDevice device)
: base(device)
{
if (PId != Constants.LOGITECH_G933_PRODUCT_ID)
{
throw new Exception("Invalid Device");
}
if (VId != Constants.LOGITECH_VENDOR_ID)
{
throw new Exception("Invalid Device");
}
}
public LedgerManager(IHidDevice ledgerHidDevice, ICoinUtility coinUtility, ErrorPromptDelegate errorPrompt)
{
ErrorPrompt = errorPrompt;
LedgerHidDevice = ledgerHidDevice;
CoinUtility = coinUtility;
if (CoinUtility == null)
{
CoinUtility = new DefaultCoinUtility();
}
SetCoinNumber(0);
}
/// <summary>
/// Connects the AerionInput main instance with a plugged NDOF-device by
/// passing a predicate.
/// Instructs m_IHidDevice to handle incoming data and sets the global Type of
/// the device.
/// </summary>
/// <returns>true if device is connected</returns>
private bool ConnectSpacePilot()
{
if ((m_IHidDevice = m_HidControl.GetDeviceByPredicate(new Predicate <IHidDeviceInfo>(IsSpacePilot))) != null)
{
Console.Out.WriteLine("SpacePilot connected");
m_IHidDevice.StartInPipeThread();
m_Type = c_SpacePilotDeviceType;
return(true);
}
else
{
return(false);
}
}
private static HidReport WriteAndReadReport(IHidDevice device, byte reportId, byte[] data)
{
var outData = device.CreateReport();
outData.ReportId = reportId;
outData.Data = data;
device.WriteReport(outData);
while (outData.ReadStatus != HidDeviceData.ReadStatus.Success)
{
Thread.Sleep(1);
}
var report = device.ReadReport();
return(report);
}
public static async Task WriteReportStreamAsync(this IHidDevice device, IAsyncEnumerable <IHidReport> stream, CancellationToken token = default)
{
if (device == null)
{
throw new ArgumentNullException($"{nameof(device)} is null");
}
if (stream == null)
{
throw new ArgumentNullException($"{nameof(stream)} is null");
}
await foreach (var item in stream.WithCancellation(token))
{
await device.WriteReportAsync(item, token).ConfigureAwait(false);
}
}
public void GiveBackDevice(IHidDevice HidDev)
{
if (HidDev != null)
{
try
{
HidDev.StopInPipeThread();
}
finally
{
HidDev = null;
}
EmitLogMessage(HidLogMessageType.Info, "Device checked in.");
}
}
public HidConsoleDevice(IHidDevice device)
{
HidDevice = device;
HidDevice.OpenDevice();
ManufacturerString = GetManufacturerString(HidDevice);
ProductString = GetProductString(HidDevice);
VendorId = (ushort)HidDevice.Attributes.VendorId;
ProductId = (ushort)HidDevice.Attributes.ProductId;
RevisionBcd = (ushort)HidDevice.Attributes.Version;
HidDevice.MonitorDeviceEvents = true;
HidDevice.ReadReport(HidDeviceReportEvent);
HidDevice.CloseDevice();
}
private async void DevicePoller_DeviceInitialized(object sender, DeviceEventArgs e)
{
_rs28Device = (IHidDevice)e.Device;
try
{
while (true)
{
FootpedalStatus status = await ReadStatusAsync();
StatusChanged?.Invoke(this, new FootpedalEventArgs(status));
}
}
catch (Exception)
{
/* Probably due to device being uplugged */
}
}
/// <summary>
/// Clean up managed and unmanged ressources by hand.
/// </summary>
/// <param name="Disposing"></param>
protected void Dispose(bool Disposing)
{
if (!IsDisposed)
{
if (Disposing)
{
//Clean Up managed resources
m_IHidDevice = null;
m_Device = null;
//Ensure we clean-up references to event
m_SensorInput = null;
}
//Clean up unmanaged resources
}
IsDisposed = true;
}
/// <summary>
/// Initializes a new instance of the CommandCenter class using the specified missile launcher model and HID library implementation.
/// </summary>
/// <param name="launcher">missile launcher model you want to control</param>
/// <param name="device">HID library that will be used</param>
/// <remarks>This is only for testing - HidLibrary is the default library for production use</remarks>
internal CommandCenter(ILauncherModel launcher, IHidDevice device)
{
if (launcher == null)
{
throw new ArgumentException(Resources.LauncherIsNull);
}
if (device == null)
{
throw new ArgumentException(Resources.DeviceIsNull);
}
this.launcher = launcher;
this.device = device;
this.sets = new CommandSetList();
device.Initialize(launcher.VendorId, launcher.DeviceId);
}
public static async Task AuthenticateAsync(IHidDevice hidDevice, DeviceRegistration deviceRegistration, string appId, string facet, bool checkOnly = false, CancellationToken?cancellationToken = null)
{
cancellationToken = cancellationToken ?? CancellationToken.None;
if (hidDevice == null || !hidDevice.IsConnected)
{
throw new ArgumentException("Hid device not connected", nameof(hidDevice));
}
using (var u2fHidDevice = await U2FHidDevice.OpenAsync(hidDevice))
{
var startAuthentication = U2F.StartAuthentication(appId, deviceRegistration);
Log.Debug("Touch token to authenticate");
var authenticateResponse = await WaitForTokenInputAsync(() => U2Fv2.AuthenticateAsync(u2fHidDevice, startAuthentication, facet, checkOnly), cancellationToken.Value).ConfigureAwait(false);
U2F.FinishAuthentication(startAuthentication, authenticateResponse, deviceRegistration);
Log.Debug("Authenticated");
}
}
/// <summary>
/// Clean up managed and unmanged ressources by hand.
/// </summary>
/// <param name="Disposing"></param>
protected void Dispose(bool Disposing)
{
if (!IsDisposed)
{
if (Disposing)
{
//Clean Up managed resources
Disconnect();
m_HidControl = null;
m_IHidDevice = null;
m_Sensor.Dispose();
m_Keyboard.Dispose();
//Ensure we clean-up references to event
m_DeviceChange = null;
}
//Clean up unmanaged resources
}
IsDisposed = true;
}
public static async Task <U2FHidKey> OpenAsync([NotNull] IHidDevice device, bool closeDeviceOnDispose = true)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
var instance = new U2FHidKey(device, closeDeviceOnDispose);
try
{
await instance.InitAsync();
return(instance);
}
catch
{
instance.Dispose();
throw;
}
}
public static async Task WriteFidoU2FHidMessageAsync([NotNull] this IHidDevice device,
FidoU2FHidMessage message, CancellationToken cancellationToken)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
log.Debug($"Sending U2FHid message {message.Command} on channel 0x{message.Channel:X8} with {message.Data.Count} bytes of data");
var report = device.CreateOutputReport();
var packets = MakeOutputPackets(report.Data.Count, message);
packets.Item1.WriteTo(report.Data);
await device.SendOutputReportAsync(report, cancellationToken);
foreach (var continuation in packets.Item2)
{
await device.SendOutputReportAsync(ToOutputReport(device, continuation), cancellationToken);
}
}
public static async Task <DeviceRegistration> RegisterAsync(IHidDevice hidDevice, string appId, string facet, CancellationToken?cancellationToken = null)
{
cancellationToken = cancellationToken ?? CancellationToken.None;
if (hidDevice == null || !hidDevice.IsConnected)
{
throw new ArgumentException("Hid device not connected", nameof(hidDevice));
}
using (var u2fHidDevice = await U2FHidDevice.OpenAsync(hidDevice))
{
var startRegistration = U2F.StartRegistration(appId);
Log.Debug("Touch token to register");
var registerResponse = await WaitForTokenInputAsync(() => U2Fv2.RegisterAsync(u2fHidDevice, startRegistration, facet), cancellationToken.Value);
var deviceRegistration = U2F.FinishRegistration(startRegistration, registerResponse);
Log.Debug("Registered");
return(deviceRegistration);
}
}
private static string GetParentIdPrefix(IHidDevice d) => Regex.Match(d.DevicePath, "#([&0-9a-fA-F]+)#").Groups[1].ToString();
public void InitSensor(Device p_Device, IHidDevice p_IHidDevice)
{
m_Device = p_Device;
m_HidDeviceEvents_HidDataReceivedEventHandler = new EventHandler<HidDataReceivedEventArgs>(HidDataReceived);
m_IHidDevice = p_IHidDevice;
m_IHidDevice.DataReceived += m_HidDeviceEvents_HidDataReceivedEventHandler;
}
static IHidOutputReport ToOutputReport(IHidDevice device, ContinuationPacket continuation)
{
var report = device.CreateOutputReport();
continuation.WriteTo(report.Data);
return report;
}
/// <summary>
/// Clean up managed and unmanged ressources by hand.
/// </summary>
/// <param name="Disposing"></param>
protected void Dispose(bool Disposing)
{
if (!IsDisposed)
{
if (Disposing)
{
//Clean Up managed resources
Disconnect();
m_HidControl = null;
m_IHidDevice = null;
m_Sensor.Dispose();
m_Keyboard.Dispose();
//Ensure we clean-up references to event
m_DeviceChange = null;
}
//Clean up unmanaged resources
}
IsDisposed = true;
}
public void GiveBackDevice(IHidDevice HidDev)
{
if (HidDev != null)
{
try
{
HidDev.StopInPipeThread();
}
finally
{
HidDev = null;
}
EmitLogMessage(HidLogMessageType.Info, "Device checked in.");
}
}
/// <summary>
/// Connects the AerionInput main instance with a plugged NDOF-device by
/// passing a predicate.
/// Instructs m_IHidDevice to handle incoming data and sets the global Type of
/// the device.
/// </summary>
/// <returns>true if device is connected</returns>
private bool ConnectAerion()
{
if ((m_IHidDevice = m_HidControl.GetDeviceByPredicate(new Predicate<IHidDeviceInfo>(IsAerion))) != null)
{
Console.Out.WriteLine("Aerion connected");
m_IHidDevice.StartInPipeThread();
m_Type = c_AerionDeviceType;
return true;
}
else return false;
}
/// <summary>
/// Connects the AerionInput main instance with a plugged NDOF-device by
/// passing a predicate.
/// Instructs m_IHidDevice to handle incoming data and sets the global Type of
/// the device.
/// </summary>
/// <returns>true if device is connected</returns>
private bool ConnectSpaceTraveler()
{
if ((m_IHidDevice = m_HidControl.GetDeviceByPredicate(new Predicate<IHidDeviceInfo>(IsSpaceTraveler))) != null)
{
Console.Out.WriteLine("SpaceTraveler connected");
m_IHidDevice.StartInPipeThread();
m_Type = c_SpaceTravelerDeviceType;
return true;
}
else return false;
}
/// <summary>
/// Clean up managed and unmanged ressources by hand.
/// </summary>
/// <param name="Disposing"></param>
protected void Dispose(bool Disposing)
{
if (!IsDisposed)
{
if (Disposing)
{
//Clean Up managed resources
m_IHidDevice = null;
m_Device = null;
//Ensure we clean-up references to event
m_KeyUp = null;
m_KeyDown = null;
}
//Clean up unmanaged resources
}
IsDisposed = true;
}
public BigRedButton()
{
var hidEnumerator = new HidEnumerator();
device = hidEnumerator.Enumerate(VendorId, ProductId).FirstOrDefault();
}
public void InitKeyboard(Device p_Device, IHidDevice p_IHidDevice)
{
m_Device = p_Device;
m_HidDeviceEvents_HidDataReceivedEventHandler = new EventHandler<HidDataReceivedEventArgs>(HidDataReceived);
m_IHidDevice = p_IHidDevice;
m_IHidDevice.DataReceived += m_HidDeviceEvents_HidDataReceivedEventHandler;
m_Keys = 2;
m_ProgrammableKeys = 0;
#region Feature Report??
//////////////////////////////////////////////
// hier muss vom Aerion abgefragt werden, wieviele Tasten er hat
// und der InitKeyboard entsprechend aufgerufen werden.
// irgendwie so:
// HidReport m_HIDFeatureReport = p_IHidDevice.ReadFeatureReport();
/*
try
{
byte[] buffer = {
p_HidDataReceivedEventArgs[1],
p_HidDataReceivedEventArgs[2],
p_HidDataReceivedEventArgs[3],
p_HidDataReceivedEventArgs[4],
p_HidDataReceivedEventArgs[5],
p_HidDataReceivedEventArgs[6],
};
System.IO.MemoryStream stream = new System.IO.MemoryStream(buffer, 0, buffer.Length);
System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);
m_keys = Convert.ToInt64(reader.ReadInt16());
bool status = reader.ReadBoolean();
}
catch (Exception e)
{
Console.Out.WriteLine("Exception: {0}", e.GetType());
}
*/
#endregion
m_KeyDownList = new BitArray(8, false);
m_KeyNameList = new string[m_Keys];
m_KeyLabelList = new string[m_Keys];
}
public ClearwareAmpel(IHidDevice device) : this(new [] { device}) { }
