Merge branch 'develop' into #19-Android

src/Device.Net - All.sln

@@ -72,6 +72,8 @@ Global
 		{8E29E247-78B7-4FC8-AF1C-DA273050978C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8E29E247-78B7-4FC8-AF1C-DA273050978C}.Release|Any CPU.Build.0 = Release|Any CPU
 		{63695F84-3EC6-4F6A-8C8C-5219D75EDB68}.Debug|Any CPU.ActiveCfg = Debug|x86
+		{63695F84-3EC6-4F6A-8C8C-5219D75EDB68}.Debug|Any CPU.Build.0 = Debug|x86
+		{63695F84-3EC6-4F6A-8C8C-5219D75EDB68}.Debug|Any CPU.Deploy.0 = Debug|x86
 		{63695F84-3EC6-4F6A-8C8C-5219D75EDB68}.Release|Any CPU.ActiveCfg = Release|x86
 		{63695F84-3EC6-4F6A-8C8C-5219D75EDB68}.Release|Any CPU.Build.0 = Release|x86
 		{63695F84-3EC6-4F6A-8C8C-5219D75EDB68}.Release|Any CPU.Deploy.0 = Release|x86

src/Device.Net.LibUsb/LibUsbDevice.cs

@@ -3,30 +3,33 @@
 using LibUsbDotNet.Main;
 using LibUsbDotNet.WinUsb;
 using System;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace Device.Net.LibUsb
 {
-    public class LibUsbDevice : IDevice
+    public class LibUsbDevice : DeviceBase, IDevice
     {
         #region Fields
         private UsbEndpointReader _UsbEndpointReader;
         private UsbEndpointWriter _UsbEndpointWriter;
         private int ReadPacketSize;
         private SemaphoreSlim _WriteAndReadLock = new SemaphoreSlim(1, 1);
         private bool disposed;
+        private bool _IsInitialized;
         #endregion
 
         #region Public Properties
         public UsbDevice UsbDevice { get; }
         public int VendorId => GetVendorId(UsbDevice);
         public int ProductId => GetProductId(UsbDevice);
         public int Timeout { get; }
-        public bool IsInitialized { get; private set; }
-        public ConnectedDeviceDefinitionBase ConnectedDeviceDefinition => throw new NotImplementedException();
+        public override bool IsInitialized => _IsInitialized;
         public string DeviceId => UsbDevice.DevicePath;
         public ILogger Logger { get; set; }
+        public override ushort WriteBufferSize => throw new NotImplementedException();
+        public override ushort ReadBufferSize => throw new NotImplementedException();
         #endregion
 
         #region Events
@@ -35,7 +38,11 @@ public class LibUsbDevice : IDevice
         #endregion
 
         #region Constructor
-        public LibUsbDevice(UsbDevice usbDevice, int timeout)
+        public LibUsbDevice(UsbDevice usbDevice, int timeout) : this(usbDevice, timeout, null, null)
+        {
+        }
+
+        public LibUsbDevice(UsbDevice usbDevice, int timeout, ILogger logger, ITracer tracer) : base(logger, tracer)
         {
             UsbDevice = usbDevice;
             Timeout = timeout;
@@ -86,23 +93,25 @@ public async Task InitializeAsync()
                 _UsbEndpointReader = UsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
                 ReadPacketSize = _UsbEndpointReader.EndpointInfo.Descriptor.MaxPacketSize;
 
-                IsInitialized = true;
+                _IsInitialized = true;
             });
         }
 
-        public async Task<byte[]> ReadAsync()
+        public override async Task<byte[]> ReadAsync()
         {
             await _WriteAndReadLock.WaitAsync();
 
             try
             {
                 return await Task.Run(() =>
                 {
-                    var buffer = new byte[ReadPacketSize];
+                    var data = new byte[ReadPacketSize];
 
-                    _UsbEndpointReader.Read(buffer, Timeout, out var bytesRead);
+                    _UsbEndpointReader.Read(data, Timeout, out var bytesRead);
 
-                    return buffer;
+                    Tracer?.Trace(false, data);
+
+                    return data;
                 });
             }
             finally
@@ -111,15 +120,25 @@ public async Task<byte[]> ReadAsync()
             }
         }
 
-        public async Task WriteAsync(byte[] data)
+        public override async Task WriteAsync(byte[] data)
         {
             await _WriteAndReadLock.WaitAsync();
 
             try
             {
                 await Task.Run(() =>
                 {
-                    _UsbEndpointWriter.Write(data, Timeout, out var bytesWritten);
+                    var errorCode = _UsbEndpointWriter.Write(data, Timeout, out var bytesWritten);
+                    if (errorCode == ErrorCode.Ok || errorCode == ErrorCode.Success)
+                    {
+                        Tracer?.Trace(true, data);
+                    }
+                    else
+                    {
+                        var message = $"Error. Write error code: {errorCode}";
+                        Logger?.Log(message, GetType().Name, null, LogLevel.Error);
+                        throw new IOException(message);
+                    }
                 });
             }
             finally
@@ -128,11 +147,6 @@ public async Task WriteAsync(byte[] data)
             }
         }
 
-        public async Task<byte[]> WriteAndReadAsync(byte[] writeBuffer)
-        {
-            await WriteAsync(writeBuffer);
-            return await ReadAsync();
-        }
         #endregion
 
         #region Public Static Methods

src/Device.Net.LibUsb/LibUsbDeviceFactoryBase.cs

@@ -9,7 +9,8 @@ namespace Device.Net.LibUsb
     public abstract class LibUsbDeviceFactoryBase : IDeviceFactory
     {
         #region Public Properties
-        public ILogger Logger { get; set; }
+        public ILogger Logger { get; }
+        public ITracer Tracer { get; }
         #endregion
 
         #region Public Abstraction Properties
@@ -56,7 +57,15 @@ public IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
         {
             var usbDeviceFinder = new UsbDeviceFinder((int)deviceDefinition.VendorId.Value, (int)deviceDefinition.ProductId.Value);
             var usbDevice = UsbDevice.OpenUsbDevice(usbDeviceFinder);
-            return usbDevice != null ? new LibUsbDevice(usbDevice, 3000) { Logger = Logger } : null;
+            return usbDevice != null ? new LibUsbDevice(usbDevice, 3000, Logger, Tracer) : null;
+        }
+        #endregion
+
+        #region Constructor
+        protected LibUsbDeviceFactoryBase(ILogger logger, ITracer tracer)
+        {
+            Logger = logger;
+            Tracer = tracer;
         }
         #endregion
     }

src/Device.Net.LibUsb/LibUsbUsbDeviceFactory.cs

@@ -2,16 +2,18 @@
 {
     public class LibUsbUsbDeviceFactory : LibUsbDeviceFactoryBase
     {
-        public override DeviceType DeviceType => DeviceType.Usb;
-
-        public static void Register()
+        public LibUsbUsbDeviceFactory(ILogger logger, ITracer tracer) : base(logger, tracer)
         {
-            Register(null);
         }
 
-        public static void Register(ILogger logger)
+        public override DeviceType DeviceType => DeviceType.Usb;
+
+        /// <summary>
+        /// Register the factory for enumerating USB devices.
+        /// </summary>
+        public static void Register(ILogger logger, ITracer tracer)
         {
-            DeviceManager.Current.DeviceFactories.Add(new LibUsbUsbDeviceFactory() { Logger = logger });
+            DeviceManager.Current.DeviceFactories.Add(new LibUsbUsbDeviceFactory(logger, tracer));
         }
     }
 }

src/Device.Net.UWP/UWPDeviceBase - Generic.cs

@@ -16,12 +16,7 @@ public abstract class UWPDeviceBase<T> : UWPDeviceBase, IDevice
         #endregion
 
         #region Constructor
-        protected UWPDeviceBase()
-        {
-
-        }
-
-        protected UWPDeviceBase(string deviceId)
+        protected UWPDeviceBase(string deviceId, ILogger logger, ITracer tracer) : base(logger, tracer)
         {
             DeviceId = deviceId;
         }
@@ -53,16 +48,19 @@ public override async Task<byte[]> ReadAsync()
             {
                 if (Chunks.Count > 0)
                 {
-                    var retVal = Chunks[0];
-                    Tracer?.Trace(false, retVal);
+                    var data2 = Chunks[0];
+                    Logger?.Log("Received data from device", GetType().Name, null, LogLevel.Information);
                     Chunks.RemoveAt(0);
-                    return retVal;
+                    Tracer?.Trace(false, data2);
+                    return data2;
                 }
             }
 
             IsReading = true;
             ReadChunkTaskCompletionSource = new TaskCompletionSource<byte[]>();
-            return await ReadChunkTaskCompletionSource.Task;
+            var data = await ReadChunkTaskCompletionSource.Task;
+            Tracer?.Trace(false, data);
+            return data;
         }
         #endregion
 

src/Device.Net.UWP/UWPDeviceBase.cs

@@ -35,5 +35,11 @@ protected void HandleDataReceived(byte[] bytes)
         #region Public Abstract Methods
         public abstract Task InitializeAsync();
         #endregion
+
+        #region Constructor
+        protected UWPDeviceBase(ILogger logger, ITracer tracer) : base(logger, tracer)
+        {
+        }
+        #endregion
     }
 }

src/Device.Net.UWP/UWPDeviceFactoryBase.cs

@@ -23,7 +23,8 @@ public abstract class UWPDeviceFactoryBase
         #endregion
 
         #region Public Properties
-        public ILogger Logger { get; set; }
+        public ILogger Logger { get;  }
+        public ITracer Tracer { get; }
         #endregion
 
         #region Public Abstract Properties
@@ -34,6 +35,14 @@ public abstract class UWPDeviceFactoryBase
         protected abstract string GetAqsFilter(uint? vendorId, uint? productId);
         #endregion
 
+        #region Constructor
+        protected UWPDeviceFactoryBase(ILogger logger, ITracer tracer)
+        {
+            Logger = logger;
+            Tracer = tracer;
+        }
+        #endregion
+
         #region Abstraction Methods
         protected string GetVendorPart(uint? vendorId)
         {

src/Device.Net.UnitTests/MockDeviceBase.cs

@@ -11,6 +11,11 @@ public abstract class MockDeviceBase : DeviceBase, IDevice
 
         public override bool IsInitialized => _IsInitialized;
 
+        protected MockDeviceBase(ILogger logger, ITracer tracer) : base(logger, tracer)
+        {
+
+        }
+
         public void Close()
         {
         }
@@ -23,16 +28,22 @@ public Task InitializeAsync()
 
         private byte[] LastWrittenBuffer;
 
-        public async override Task<byte[]> ReadAsync()
+        public override async Task<byte[]> ReadAsync()
         {
-            if (LastWrittenBuffer != null) return LastWrittenBuffer;
-
-            return await Task.FromResult(new byte[64] { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
+            if (LastWrittenBuffer != null)
+            {
+                Tracer.Trace(false, LastWrittenBuffer);
+                return LastWrittenBuffer;
+            }
+            var data = new byte[64] { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+            Tracer.Trace(false, data);
+            return await Task.FromResult(data);
         }
 
         public override Task WriteAsync(byte[] data)
         {
             LastWrittenBuffer = data;
+            Tracer.Trace(true, data);
             return Task.FromResult(true);
         }
     }

src/Device.Net.UnitTests/MockFactoryBase.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace Device.Net.UnitTests
@@ -12,7 +11,14 @@ public abstract class MockFactoryBase : IDeviceFactory
 
         public abstract DeviceType DeviceType { get; }
 
-        public ILogger Logger { get; protected set; }
+        public ILogger Logger { get; }
+        public ITracer Tracer { get; }
+
+        protected MockFactoryBase(ILogger logger, ITracer tracer)
+        {
+            Logger = logger;
+            Tracer = tracer;
+        }
 
         public abstract uint ProductId { get; }
         public abstract uint VendorId { get; }
@@ -23,6 +29,15 @@ public Task<IEnumerable<ConnectedDeviceDefinition>> GetConnectedDeviceDefinition
 
             var mockConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId) { ProductId = ProductId, VendorId = VendorId };
 
+            if (this is MockHidFactory mockHidFactory)
+            {
+                mockConnectedDeviceDefinition.DeviceType = DeviceType.Hid;
+            }
+            else
+            {
+                mockConnectedDeviceDefinition.DeviceType = DeviceType.Usb;
+            }
+
             if (IsConnected)
             {
                 if (DeviceManager.IsDefinitionMatch(deviceDefinition, mockConnectedDeviceDefinition))

src/Device.Net.UnitTests/MockHidDevice.cs

@@ -6,11 +6,10 @@ public class MockHidDevice : MockDeviceBase, IDevice
         public const uint VendorId = 1;
         public const string MockedDeviceId = "123";
 
-        public MockHidDevice()
+        public MockHidDevice(ILogger logger, ITracer tracer) : base(logger, tracer)
         {
             DeviceId = MockedDeviceId;
-            ConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId) { ProductId = ProductId, VendorId = VendorId };
-            Logger = new DebugLogger { LogToConsole = true };
+            ConnectedDeviceDefinition = new ConnectedDeviceDefinition(DeviceId) { ProductId = ProductId, VendorId = VendorId, DeviceType = DeviceType.Hid };
         }
     }
 }

src/Device.Net.UnitTests/MockHidFactory.cs

@@ -4,9 +4,10 @@ namespace Device.Net.UnitTests
 {
     public class MockHidFactory : MockFactoryBase, IDeviceFactory
     {
-        public MockHidFactory()
+        public const string FoundMessage = "Found device {0}";
+
+        public MockHidFactory(ILogger logger, ITracer tracer) : base(logger, tracer)
         {
-            Logger = new DebugLogger { LogToConsole = true };
         }
 
         public override string DeviceId => MockHidDevice.MockedDeviceId;
@@ -21,9 +22,9 @@ public MockHidFactory()
 
         public override uint VendorId => MockHidDevice.VendorId;
 
-        public static void Register(ILogger logger)
+        public static void Register(ILogger logger, ITracer tracer)
         {
-            DeviceManager.Current.DeviceFactories.Add(new MockHidFactory() { Logger = logger });
+            DeviceManager.Current.DeviceFactories.Add(new MockHidFactory(logger, tracer));
         }
 
         public override IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
@@ -32,11 +33,16 @@ public override IDevice GetDevice(ConnectedDeviceDefinition deviceDefinition)
             {
                 if (deviceDefinition.DeviceId == DeviceId)
                 {
-                    if (!deviceDefinition.DeviceType.HasValue || deviceDefinition.DeviceType == DeviceType.Hid) return new MockHidDevice();
+                    if (!deviceDefinition.DeviceType.HasValue || deviceDefinition.DeviceType == DeviceType.Hid)
+                    {
+                        Logger?.Log(string.Format(FoundMessage, DeviceId), nameof(MockHidFactory), null, LogLevel.Information);
+
+                        return new MockHidDevice(Logger, Tracer);
+                    }
                 }
             }
 
-            throw new Exception("Couldn't get a device");
+            return null;
         }
     }
 }