protected override ConnectedDeviceDefinition GetDeviceDefinition(string deviceId)
{
using (var safeFileHandle = APICalls.CreateFile(deviceId, APICalls.GenericRead | APICalls.GenericWrite, APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, 0, IntPtr.Zero))
{
return(GetDeviceDefinition(deviceId, safeFileHandle));
}
}
private bool Initialize()
{
Dispose();
if (string.IsNullOrEmpty(DeviceId))
{
throw new WindowsHidException($"{nameof(DeviceId)} must be specified before {nameof(Initialize)} can be called.");
}
_ReadSafeFileHandle = APICalls.CreateFile(DeviceId, APICalls.GenericRead | APICalls.GenericWrite, APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, 0, IntPtr.Zero);
_WriteSafeFileHandle = APICalls.CreateFile(DeviceId, APICalls.GenericRead | APICalls.GenericWrite, APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, 0, IntPtr.Zero);
if (_ReadSafeFileHandle.IsInvalid)
{
throw new Exception("Could not open connection for reading");
}
if (_WriteSafeFileHandle.IsInvalid)
{
throw new Exception("Could not open connection for writing");
}
ConnectedDeviceDefinition = WindowsHidDeviceFactory.GetDeviceDefinition(DeviceId, _ReadSafeFileHandle);
_ReadFileStream = new FileStream(_ReadSafeFileHandle, FileAccess.ReadWrite, ReadBufferSize, false);
_WriteFileStream = new FileStream(_WriteSafeFileHandle, FileAccess.ReadWrite, WriteBufferSize, false);
return(true);
}
protected override ConnectedDeviceDefinition GetDeviceDefinition(string deviceId)
{
try
{
const uint desiredAccess = APICalls.GenericRead | APICalls.GenericWrite;
const uint shareMode = APICalls.FileShareRead | APICalls.FileShareWrite;
const uint creationDisposition = APICalls.OpenExisting;
//Don't request any access here...
//TODO: Put a nicer number than 0 here
using (var safeFileHandle = APICalls.CreateFile(deviceId, 0, shareMode, IntPtr.Zero, creationDisposition, 0, IntPtr.Zero))
{
if (safeFileHandle.IsInvalid)
{
throw new DeviceException($"CreateFile call with Id of {deviceId} failed. Desired Access: {desiredAccess} (GenericRead / GenericWrite). Share mode: {shareMode} (FileShareRead / FileShareWrite). Creation Disposition: {creationDisposition} (OpenExisting)");
}
Logger?.Log($"Found device {deviceId}", nameof(WindowsHidDeviceFactory), null, LogLevel.Information);
return(GetDeviceDefinition(deviceId, safeFileHandle));
}
}
catch (Exception ex)
{
Logger?.Log($"{nameof(GetDeviceDefinition)} error. Device Id: {deviceId}", nameof(WindowsHidDeviceFactory), ex, LogLevel.Error);
return(null);
}
}
private void Initialize()
{
Dispose();
int errorCode;
if (string.IsNullOrEmpty(DeviceId))
{
throw new WindowsException($"{nameof(DeviceDefinitionBase)} must be specified before {nameof(InitializeAsync)} can be called.");
}
_DeviceHandle = APICalls.CreateFile(DeviceId, (APICalls.GenericWrite | APICalls.GenericRead), APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, APICalls.FileAttributeNormal | APICalls.FileFlagOverlapped, IntPtr.Zero);
if (_DeviceHandle.IsInvalid)
{
//TODO: is error code useful here?
errorCode = Marshal.GetLastWin32Error();
if (errorCode > 0)
{
throw new Exception($"Device handle no good. Error code: {errorCode}");
}
}
var isSuccess = WinUsbApiCalls.WinUsb_Initialize(_DeviceHandle, out var defaultInterfaceHandle);
HandleError(isSuccess, "Couldn't initialize device");
ConnectedDeviceDefinition = GetDeviceDefinition(defaultInterfaceHandle, DeviceId);
byte i = 0;
//Get the first (default) interface
var defaultInterface = GetInterface(defaultInterfaceHandle);
_UsbInterfaces.Add(defaultInterface);
while (true)
{
isSuccess = WinUsbApiCalls.WinUsb_GetAssociatedInterface(defaultInterfaceHandle, i, out var interfacePointer);
if (!isSuccess)
{
errorCode = Marshal.GetLastWin32Error();
if (errorCode == APICalls.ERROR_NO_MORE_ITEMS)
{
break;
}
throw new Exception($"Could not enumerate interfaces for device {DeviceId}. Error code: { errorCode}");
}
var associatedInterface = GetInterface(interfacePointer);
_UsbInterfaces.Add(associatedInterface);
i++;
}
}
private bool Initialize()
{
try
{
Close();
if (string.IsNullOrEmpty(DeviceId))
{
throw new WindowsHidException($"{nameof(DeviceId)} must be specified before {nameof(Initialize)} can be called.");
}
_ReadSafeFileHandle = APICalls.CreateFile(DeviceId, APICalls.GenericRead | APICalls.GenericWrite, APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, 0, IntPtr.Zero);
_WriteSafeFileHandle = APICalls.CreateFile(DeviceId, APICalls.GenericRead | APICalls.GenericWrite, APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, 0, IntPtr.Zero);
if (_ReadSafeFileHandle.IsInvalid)
{
throw new Exception("Could not open connection for reading");
}
if (_WriteSafeFileHandle.IsInvalid)
{
throw new Exception("Could not open connection for writing");
}
ConnectedDeviceDefinition = WindowsHidDeviceFactory.GetDeviceDefinition(DeviceId, _ReadSafeFileHandle);
var readBufferSize = ReadBufferSize;
var writeBufferSize = WriteBufferSize;
if (readBufferSize == 0)
{
throw new WindowsHidException($"{nameof(ReadBufferSize)} must be specified. HidD_GetAttributes may have failed or returned an InputReportByteLength of 0. Please specify this argument in the constructor");
}
if (writeBufferSize == 0)
{
throw new WindowsHidException($"{nameof(WriteBufferSize)} must be specified. HidD_GetAttributes may have failed or returned an OutputReportByteLength of 0. Please specify this argument in the constructor. Note: Hid devices are always opened in write mode. If you need to open in read mode, please log an issue here: https://github.com/MelbourneDeveloper/Device.Net/issues");
}
_ReadFileStream = new FileStream(_ReadSafeFileHandle, FileAccess.ReadWrite, readBufferSize, false);
_WriteFileStream = new FileStream(_WriteSafeFileHandle, FileAccess.ReadWrite, writeBufferSize, false);
}
catch (Exception ex)
{
Logger?.Log($"{nameof(Initialize)} error.", nameof(WindowsHidDevice), ex, LogLevel.Error);
throw;
}
return(true);
}
protected override ConnectedDeviceDefinition GetDeviceDefinition(string deviceId)
{
try
{
using (var safeFileHandle = APICalls.CreateFile(deviceId, APICalls.GenericRead | APICalls.GenericWrite, APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, 0, IntPtr.Zero))
{
return(GetDeviceDefinition(deviceId, safeFileHandle));
}
}
catch (Exception ex)
{
Logger?.Log($"{nameof(GetDeviceDefinition)} error. Device Id: {deviceId}", nameof(WindowsHidDeviceFactory), ex, LogLevel.Error);
return(null);
}
}
private void Initialize()
{
using var logScope = Logger.BeginScope("DeviceId: {deviceId} Call: {call}", DeviceId, nameof(Initialize));
try
{
Close();
int errorCode;
if (string.IsNullOrEmpty(DeviceId))
{
throw new ValidationException(
$"{nameof(ConnectedDeviceDefinition)} must be specified before {nameof(InitializeAsync)} can be called.");
}
_DeviceHandle = APICalls.CreateFile(DeviceId,
FileAccessRights.GenericWrite | FileAccessRights.GenericRead,
APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting,
APICalls.FileAttributeNormal | APICalls.FileFlagOverlapped, IntPtr.Zero);
if (_DeviceHandle.IsInvalid)
{
//TODO: is error code useful here?
errorCode = Marshal.GetLastWin32Error();
if (errorCode > 0)
{
throw new ApiException($"Device handle no good. Error code: {errorCode}");
}
}
Logger.LogInformation(Messages.SuccessMessageGotWriteAndReadHandle);
var isSuccess = WinUsbApiCalls.WinUsb_Initialize(_DeviceHandle, out var interfaceHandle);
_ = WindowsHelpers.HandleError(isSuccess, Messages.ErrorMessageCouldntIntializeDevice, Logger);
#pragma warning disable CA2000 //We need to hold on to this handle
var defaultInterfaceHandle = new SafeFileHandle(interfaceHandle, false);
#pragma warning restore CA2000
var connectedDeviceDefinition = GetDeviceDefinition(defaultInterfaceHandle, DeviceId, Logger);
if (!WriteBufferSizeProtected.HasValue)
{
if (!connectedDeviceDefinition.WriteBufferSize.HasValue)
{
throw new ValidationException("Write buffer size not specified");
}
WriteBufferSizeProtected = (ushort)connectedDeviceDefinition.WriteBufferSize.Value;
}
if (!ReadBufferSizeProtected.HasValue)
{
if (!connectedDeviceDefinition.ReadBufferSize.HasValue)
{
throw new ValidationException("Read buffer size not specified");
}
ReadBufferSizeProtected = (ushort)connectedDeviceDefinition.ReadBufferSize.Value;
}
//Get the first (default) interface
#pragma warning disable CA2000 //Ths should be disposed later
var defaultInterface = GetInterface(defaultInterfaceHandle);
UsbInterfaces.Add(defaultInterface);
byte i = 0;
while (true)
{
isSuccess = WinUsbApiCalls.WinUsb_GetAssociatedInterface(defaultInterfaceHandle, i,
out var interfacePointer);
if (!isSuccess)
{
errorCode = Marshal.GetLastWin32Error();
if (errorCode == APICalls.ERROR_NO_MORE_ITEMS)
{
break;
}
throw new ApiException(
$"Could not enumerate interfaces for device. Error code: {errorCode}");
}
var associatedInterface = GetInterface(interfacePointer);
//TODO: this is bad design. The handler should be taking care of this
UsbInterfaces.Add(associatedInterface);
i++;
}
RegisterDefaultInterfaces();
#pragma warning restore CA2000
}
catch (Exception ex)
{
Logger.LogError(ex, Messages.ErrorMessageCouldntIntializeDevice);
throw;
}
}
private void Initialize()
{
try
{
Close();
int errorCode;
if (string.IsNullOrEmpty(DeviceId))
{
throw new ValidationException($"{nameof(DeviceDefinitionBase)} must be specified before {nameof(InitializeAsync)} can be called.");
}
_DeviceHandle = APICalls.CreateFile(DeviceId, FileAccessRights.GenericWrite | FileAccessRights.GenericRead, APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, APICalls.FileAttributeNormal | APICalls.FileFlagOverlapped, IntPtr.Zero);
if (_DeviceHandle.IsInvalid)
{
//TODO: is error code useful here?
errorCode = Marshal.GetLastWin32Error();
if (errorCode > 0)
{
throw new ApiException($"Device handle no good. Error code: {errorCode}");
}
}
Logger?.Log(Messages.SuccessMessageGotWriteAndReadHandle, nameof(WindowsUsbInterfaceManager), null, LogLevel.Information);
var isSuccess = WinUsbApiCalls.WinUsb_Initialize(_DeviceHandle, out var defaultInterfaceHandle);
WindowsDeviceBase.HandleError(isSuccess, Messages.ErrorMessageCouldntIntializeDevice);
var connectedDeviceDefinition = WindowsUsbDeviceFactory.GetDeviceDefinition(defaultInterfaceHandle, DeviceId);
if (!_WriteBufferSize.HasValue)
{
if (!connectedDeviceDefinition.WriteBufferSize.HasValue)
{
throw new ValidationException("Write buffer size not specified");
}
_WriteBufferSize = (ushort)connectedDeviceDefinition.WriteBufferSize.Value;
}
if (!_ReadBufferSize.HasValue)
{
if (!connectedDeviceDefinition.ReadBufferSize.HasValue)
{
throw new ValidationException("Read buffer size not specified");
}
_ReadBufferSize = (ushort)connectedDeviceDefinition.ReadBufferSize.Value;
}
//Get the first (default) interface
var defaultInterface = GetInterface(defaultInterfaceHandle);
UsbInterfaces.Add(defaultInterface);
byte i = 0;
while (true)
{
isSuccess = WinUsbApiCalls.WinUsb_GetAssociatedInterface(defaultInterfaceHandle, i, out var interfacePointer);
if (!isSuccess)
{
errorCode = Marshal.GetLastWin32Error();
if (errorCode == APICalls.ERROR_NO_MORE_ITEMS)
{
break;
}
throw new ApiException($"Could not enumerate interfaces for device. Error code: { errorCode}");
}
var associatedInterface = GetInterface(interfacePointer);
//TODO: this is bad design. The handler should be taking care of this
UsbInterfaces.Add(associatedInterface);
i++;
}
RegisterDefaultInterfaces();
}
catch (Exception ex)
{
Logger?.Log($"{nameof(Initialize)} error. DeviceId {DeviceId}", nameof(UsbDevice), ex, LogLevel.Error);
throw;
}
}
private bool Initialize()
{
try
{
Close();
if (string.IsNullOrEmpty(DeviceId))
{
throw new ValidationException($"{nameof(DeviceId)} must be specified before {nameof(Initialize)} can be called.");
}
//TODO: Work on getting these correct, and make sure that different values can be passed in here.
_ReadSafeFileHandle = APICalls.CreateFile(DeviceId, APICalls.GenericRead, 3, IntPtr.Zero, APICalls.OpenExisting, 0, IntPtr.Zero);
_WriteSafeFileHandle = APICalls.CreateFile(DeviceId, APICalls.GenericRead | APICalls.GenericWrite, APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, 0, IntPtr.Zero);
if (_ReadSafeFileHandle.IsInvalid)
{
throw new ApiException(Messages.ErrorMessageCantOpenRead);
}
IsReadOnly = _WriteSafeFileHandle.IsInvalid ? true : false;
if (IsReadOnly.Value)
{
Logger?.Log(Messages.WarningMessageOpeningInReadonlyMode(DeviceId), nameof(WindowsHidDevice), null, LogLevel.Warning);
}
ConnectedDeviceDefinition = WindowsHidDeviceFactory.GetDeviceDefinition(DeviceId, _ReadSafeFileHandle, Logger);
var readBufferSize = ReadBufferSize;
var writeBufferSize = WriteBufferSize;
if (readBufferSize == 0)
{
throw new ValidationException($"{nameof(ReadBufferSize)} must be specified. HidD_GetAttributes may have failed or returned an InputReportByteLength of 0. Please specify this argument in the constructor");
}
_ReadFileStream = new FileStream(_ReadSafeFileHandle, FileAccess.Read, readBufferSize, false);
if (_ReadFileStream.CanRead)
{
Logger?.Log(Messages.SuccessMessageReadFileStreamOpened, nameof(WindowsHidDevice), null, LogLevel.Information);
}
else
{
Logger?.Log(Messages.WarningMessageReadFileStreamCantRead, nameof(WindowsHidDevice), null, LogLevel.Warning);
}
if (!IsReadOnly.Value)
{
if (writeBufferSize == 0)
{
throw new ValidationException($"{nameof(WriteBufferSize)} must be specified. HidD_GetAttributes may have failed or returned an OutputReportByteLength of 0. Please specify this argument in the constructor");
}
//Don't open if this is a read only connection
_WriteFileStream = new FileStream(_WriteSafeFileHandle, FileAccess.ReadWrite, writeBufferSize, false);
if (_WriteFileStream.CanWrite)
{
Logger?.Log(Messages.SuccessMessageWriteFileStreamOpened, nameof(WindowsHidDevice), null, LogLevel.Information);
}
else
{
Logger?.Log(Messages.WarningMessageWriteFileStreamCantWrite, nameof(WindowsHidDevice), null, LogLevel.Warning);
}
}
}
catch (Exception ex)
{
Logger?.Log($"{nameof(Initialize)} error.", nameof(WindowsHidDevice), ex, LogLevel.Error);
throw;
}
return(true);
}
private void Initialize()
{
Dispose();
int errorCode;
if (string.IsNullOrEmpty(DeviceId))
{
throw new WindowsException($"{nameof(Device.Net.DeviceDefinition)} must be specified before {nameof(InitializeAsync)} can be called.");
}
_DeviceHandle = APICalls.CreateFile(DeviceId, (APICalls.GenericWrite | APICalls.GenericRead), APICalls.FileShareRead | APICalls.FileShareWrite, IntPtr.Zero, APICalls.OpenExisting, APICalls.FileAttributeNormal | APICalls.FileFlagOverlapped, IntPtr.Zero);
if (_DeviceHandle.IsInvalid)
{
//TODO: is error code useful here?
errorCode = Marshal.GetLastWin32Error();
if (errorCode > 0)
{
throw new Exception($"Device handle no good. Error code: {errorCode}");
}
}
var isSuccess = WinUsbApiCalls.WinUsb_Initialize(_DeviceHandle, out var defaultInterfaceHandle);
HandleError(isSuccess, "Couldn't initialize device");
var bufferLength = (uint)Marshal.SizeOf(typeof(USB_DEVICE_DESCRIPTOR));
isSuccess = WinUsbApiCalls.WinUsb_GetDescriptor(defaultInterfaceHandle, WinUsbApiCalls.DEFAULT_DESCRIPTOR_TYPE, 0, EnglishLanguageID, out _UsbDeviceDescriptor, bufferLength, out var lengthTransferred);
HandleError(isSuccess, "Couldn't get device descriptor");
byte i = 0;
//Get the first (default) interface
var defaultInterface = GetInterface(defaultInterfaceHandle);
_UsbInterfaces.Add(defaultInterface);
while (true)
{
isSuccess = WinUsbApiCalls.WinUsb_GetAssociatedInterface(defaultInterfaceHandle, i, out var interfacePointer);
if (!isSuccess)
{
errorCode = Marshal.GetLastWin32Error();
if (errorCode == APICalls.ERROR_NO_MORE_ITEMS)
{
break;
}
throw new Exception($"Could not enumerate interfaces for device {DeviceId}. Error code: { errorCode}");
}
var associatedInterface = GetInterface(interfacePointer);
_UsbInterfaces.Add(associatedInterface);
i++;
}
IsInitialized = true;
}