total async IO

Demo/MauiDemo/MainPage.xaml

@@ -53,6 +53,10 @@
                                 <x:Int32>57600</x:Int32>
                                 <x:Int32>115200</x:Int32>
                                 <x:Int32>194000</x:Int32>
+                                <x:Int32>460800</x:Int32>
+                                <x:Int32>921600</x:Int32>
+                                <x:Int32>1843200</x:Int32>
+                                <x:Int32>2000000</x:Int32>
                             </x:Array>
                         </Picker.ItemsSource>
                     </Picker>
@@ -106,7 +110,7 @@
                     <Button.CommandParameter>
                         <MultiBinding Converter="{StaticResource mvc}">
                             <Binding Source="{x:Reference devicePicker}" Path="SelectedItem"  x:DataType = "Picker"/>   
-                            <Binding Source="{x:Reference baudRatePicker}" Path="SelectedItem"  x:DataType = "Picker "/>
+                            <Binding Source="{x:Reference baudRatePicker}" Path="SelectedItem"  x:DataType = "Picker"/>
                             <Binding Source="{x:Reference dataBitsPicker }" Path="SelectedItem"  x:DataType = "Picker"/>
                             <Binding Source="{x:Reference stopBitsPicker}" Path="SelectedItem"  x:DataType = "Picker"/>
                             <Binding Source="{x:Reference parityPicker}" Path="SelectedItem"  x:DataType = "Picker"/>
@@ -147,6 +151,35 @@
                 <Editor Text="{Binding ReceivedText}" />
             </StackLayout>
 
+            <StackLayout>
+                <Label Text="High load speed test" FontSize="20" 
+                       HorizontalTextAlignment="Center" TextColor="MediumPurple"/>
+
+                <Label Text="Write speed"/>
+                <Editor Text="{Binding WriteSpeed}" />
+                <Label Text="Read speed"/>
+                <Editor Text="{Binding ReadSpeed}" />
+
+                <Grid ColumnDefinitions="*,*" RowDefinitions="auto" 
+                      ColumnSpacing="4" RowSpacing="4">
+                    <Button Grid.Row="0" Grid.Column="0" Text="Start" 
+                        Command="{Binding SendReceiveCommand}">
+                        <Button.CommandParameter>
+                            <MultiBinding Converter="{StaticResource mvc}">
+                                <Binding Source="{x:Reference devicePicker}" Path="SelectedItem"  x:DataType = "Picker"/>
+                                <Binding Source="{x:Reference baudRatePicker}" Path="SelectedItem"  x:DataType = "Picker"/>
+                                <Binding Source="{x:Reference dataBitsPicker }" Path="SelectedItem"  x:DataType = "Picker"/>
+                                <Binding Source="{x:Reference stopBitsPicker}" Path="SelectedItem"  x:DataType = "Picker"/>
+                                <Binding Source="{x:Reference parityPicker}" Path="SelectedItem"  x:DataType = "Picker"/>
+                            </MultiBinding>
+                        </Button.CommandParameter>
+                    </Button>
+                    <Button Grid.Row="0" Grid.Column="1" Text="Stop" 
+                        Command="{Binding SendReceiveCancelCommand}">
+                    </Button>
+                </Grid>
+            </StackLayout>
+
             <StackLayout>
                 <Label Text="{Binding SelectedDeviceInfo.DeviceName, StringFormat='DeviceName:{0}'}" />
                 <Label Text="{Binding SelectedDeviceInfo.ProductName, StringFormat='ProductName:{0}'}" />

Demo/MauiDemo/MainPage.xaml.cs

@@ -7,11 +7,23 @@ public partial class MainPage : ContentPage
         public MainPage(MainViewModel vm)
         {
             InitializeComponent();
-            this.BindingContext = vm;
-            baudRatePicker.SelectedIndex = 6;
+            BindingContext = vm;
+            baudRatePicker.SelectedIndex = 9;
             dataBitsPicker.SelectedIndex = 3;
             stopBitsPicker.SelectedIndex = 0;
             parityPicker.SelectedIndex = 0;
         }
+        protected override void OnAppearing()
+        {
+            base.OnAppearing();
+            if (BindingContext is not MainViewModel vm)
+                return;
+            // if device already connected
+            // get all devices to list
+            // and select first
+            vm.GetAllCommand.Execute(null);
+            if (0 < vm.UsbDeviceInfos.Count)
+                vm.SelectedDeviceInfo = vm.UsbDeviceInfos[0];
+        }
     }
 }

Demo/MauiDemo/Models/IOTestModel.cs

@@ -0,0 +1,120 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using System.Diagnostics;
+using UsbSerialForAndroid.Net;
+using UsbSerialForAndroid.Net.Drivers;
+
+namespace MauiDemo.Models;
+
+public partial class IOTestModel : ObservableObject
+{
+    //private UsbDriverBase? _usbDriver;
+    [ObservableProperty] public partial string? WriteSpeed { get; set; }
+    [ObservableProperty] public partial string? ReadSpeed { get; set; }
+    public IOTestModel() { }
+
+    public static TimeSpan UpdatePreiod = TimeSpan.FromMilliseconds(1000);
+
+    public async Task StartTestAsync(int deviceId, int baudRate, byte dataBits, byte stopBits, byte parity,
+        CancellationToken ct)
+    {
+        using var usbDriver = UsbDriverFactory.CreateUsbDriver(deviceId);
+        var _stopBits = (UsbSerialForAndroid.Net.Enums.StopBits)stopBits;
+        var _parity = (UsbSerialForAndroid.Net.Enums.Parity)parity;
+        await usbDriver.OpenAsync(baudRate, dataBits, _stopBits, _parity);
+        await Task.WhenAny(ExecReadAsync(usbDriver, ct), ExecWriteAsync(usbDriver, ct));
+    }
+    public async Task ExecReadAsync(UsbDriverBase usbDriver, CancellationToken ct)
+    {
+        try
+        {
+            await ReadAsync(usbDriver, ct);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[err] {ex}");
+        }
+    }
+    public async Task ExecWriteAsync(UsbDriverBase usbDriver, CancellationToken ct)
+    {
+        try
+        {
+            await WriteAsync(usbDriver, ct);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[err] {ex}");
+        }
+    }
+    public const int SampleBufLength = 256;
+    public async Task WriteAsync(UsbDriverBase usbDriver, CancellationToken ct)
+    {
+        byte[] writeBuf = new byte[SampleBufLength];
+        // fill buf
+        for (int i = 0; i < writeBuf.Length; i++)
+            writeBuf[i] = (byte)i;
+
+        double speed = 0;
+        long sentTotal = 0;
+        long sentPrev = 0;
+        var sw = Stopwatch.StartNew();
+        TimeSpan tickPrev = sw.Elapsed;
+        while (!ct.IsCancellationRequested)
+        {
+            TimeSpan now = sw.Elapsed;
+            TimeSpan difTime = now - tickPrev;
+            if (UpdatePreiod < difTime)
+            {
+                double difBytes = sentTotal - sentPrev;
+                speed = (speed + (difBytes / difTime.TotalSeconds)) / 2;
+                WriteSpeed = $"{speed:N0} byte/sec, sent total={sentTotal}";// {difBytes:N0}  {difTime}
+                tickPrev = now;
+                sentPrev = sentTotal;
+            }
+            if (SampleBufLength != await usbDriver.WriteAsync(writeBuf, 0, writeBuf.Length, ct))
+                throw new Exception("Something write wrong");
+            sentTotal += SampleBufLength;
+        }
+    }
+    private async Task ReadAsync(UsbDriverBase usbDriver, CancellationToken ct)
+    {
+        byte[] buf = new byte[SampleBufLength];
+        byte[] testDataSample = new byte[SampleBufLength];
+        // fill buf
+        for (int i = 0; i < testDataSample.Length; i++)
+            testDataSample[i] = (byte)i;
+        double speed = 0;
+        long readTotal = 0;
+        long readPrev = 0;
+        var sw = Stopwatch.StartNew();
+        TimeSpan tickPrev = sw.Elapsed;
+        while (!ct.IsCancellationRequested)
+        {
+            TimeSpan now = sw.Elapsed;
+            TimeSpan difTime = now - tickPrev;
+            if (UpdatePreiod < difTime)
+            {
+                double difBytes = readTotal - readPrev;
+                speed = (speed + (difBytes / difTime.TotalSeconds)) / 2;
+                ReadSpeed = $"{speed:N0} byte/sec read total={readTotal}";// {difBytes:N0}  {difTime}
+                tickPrev = now;
+                readPrev = readTotal;
+            }
+            int currOffset = 0;
+            int currLen = SampleBufLength;
+            while (0 < currLen)
+            {
+                int currReadLen = await usbDriver.ReadAsync(buf, currOffset, currLen, ct);
+                currOffset += currReadLen;
+                currLen -= currReadLen;
+                readTotal += currReadLen;
+            }
+            if (!testDataSample.SequenceEqual(buf))
+            {
+                Console.WriteLine($"[err] {BitConverter.ToString(buf)}");
+                Console.WriteLine($"[err] Read {readTotal} not equal write sequence");
+                throw new Exception($"Read {readTotal} not equal write sequence");
+            }
+        }
+    }
+
+}

Demo/MauiDemo/ViewModels/MainViewModel.cs

@@ -93,6 +93,44 @@ items[3] is byte stopBits &&
                 ShowMessage(ex.Message);
             }
         });
+        [ObservableProperty] public partial string? WriteSpeed { get; set; }
+        [ObservableProperty] public partial string? ReadSpeed { get; set; }
+        [RelayCommand(IncludeCancelCommand = true)]
+        public async Task SendReceive(object[] items, CancellationToken ct)
+        {
+            try
+            {
+                if (items is null
+                || items.Length != 5
+                || items[0] is not UsbDeviceInfo usbDeviceInfo
+                || items[1] is not int baudRate
+                || items[2] is not byte dataBits
+                || items[3] is not byte stopBits
+                || items[4] is not Parity parity)
+                    return;
+                var test = new IOTestModel();
+                test.PropertyChanged += (obj, arg) =>
+                {
+                    MainThread.BeginInvokeOnMainThread(() =>
+                    {
+                        switch (arg.PropertyName)
+                        {
+                            default: break;
+                            case nameof(WriteSpeed): WriteSpeed = test.WriteSpeed; break;
+                            case nameof(ReadSpeed): ReadSpeed = test.ReadSpeed; break;
+                        }
+                    });
+                };
+                await Task.Run(() => test.StartTestAsync(usbDeviceInfo.DeviceId,
+                    baudRate, dataBits, stopBits, (byte)parity, ct), ct);
+            }
+            catch (Exception ex)
+            {
+                ShowMessage(ex.Message);
+            }
+            WriteSpeed = null;
+            ReadSpeed = null;
+        }
         public RelayCommand TestConnectCommand => new(() =>
         {
             try