Prep for Next Release (#37)

* Remove Dispose call in critical log scenario

The line `Dispose();  // clear the channels` was removed from the method where a critical log message is generated if `ChannelId` is null. This change ensures that the code will no longer call the `Dispose` method to clear the channels in this scenario.

* Refactor AntDeviceCollection and add SendMessageChannel

- Made `AntDeviceCollection` a partial class.
- Added `_sendMessageChannel` field to `AntDeviceCollection`.
- Simplified `AntDeviceCollection` constructor by removing async initialization.
- Added `StartScanning` method to initialize ANT radio and channels.
- Renamed `Channel_ChannelResponse` to `MessageHandler` and updated it.
- Refactored `CreateAntDevice` to use `_sendMessageChannel`.
- Updated `AntPlus.csproj` to version `5.0.0.0`.
- Added `SendMessageChannel` class to manage multiple ANT channels.
- Implemented async data sending and channel management in `SendMessageChannel`.

* Refactor tests and add new logging verifications

Refactored test classes to use mock loggers and updated test methods to be asynchronous. Added new tests for logging critical messages and warnings. Introduced a new `SendMessageChannelTests` class to verify `NotImplementedException` and concurrent method invocations.

* Add release notes and documentation for versions 5.0.0.0 and 1.1.1.0

Updated `AntPlus.csproj` to include new package release notes indicating breaking changes. The `AntDeviceCollection` constructor no longer initiates ANT device scanning; `StartScanning` must be called after instantiation.

Updated `AntPllusVersionHistory.aml` and `HostingExtensionsVersionHistory.aml` to include new list items with links to the new version history.

Updated `ContentLayout.content` to add new topics for versions 5.0.0.0 and 1.1.1.0, marking version 5.0.0.0 as selected.

Updated `Documentation.shfbproj` to re-add namespace summary items and include new entries for the version history files for versions 5.0.0.0 and 1.1.1.0.

Added new files `v5.0.0.0.aml` and `v1.1.1.0.aml` detailing the releases, including breaking changes, improvements, and a fix for a potential race condition.

* Remove ackWaitTime parameter and standardize timeouts

The changes primarily involve the removal of the `ackWaitTime` parameter from various method calls and method signatures. This parameter, which specified the time in milliseconds to wait for device acknowledgment, has been replaced with `It.IsAny<uint>()` in the unit tests and with a default timeout value `_deviceTimeout` in the main code.

In the unit tests within `TrainerStationaryBikeTests.cs`, the hardcoded `500` milliseconds wait time has been replaced with `It.IsAny<uint>()` to make the tests more flexible and less dependent on specific timeout values.

In the `AntDevice.cs` file, the `ackWaitTime` parameter has been removed from the `RequestDataPage` and `SendExtAcknowledgedMessage` methods. Instead, these methods now use the `_deviceTimeout` field to determine the timeout duration.

Similar changes have been made in the `Tracker.cs`, `Parameters.cs`, and `Geocache.cs` files, where the `ackWaitTime` parameter has been removed from method calls and replaced with the default timeout value.

These changes aim to standardize the timeout handling across the codebase, making it more maintainable and consistent.

* Update tests and refactor Geocache functionality

Updated NuGet packages in AntPlus.UnitTests.csproj:
- Microsoft.NET.Test.Sdk to 17.13.0
- MSTest.TestAdapter to 3.7.3
- MSTest.TestFramework to 3.7.3
- coverlet.collector to 6.0.4

GeocacheTests.cs changes:
- mockAntChannel now uses MockBehavior.Loose
- Added tests: EraseGeocache_Success_ReturnsPass and EraseGeocache_Failure_ReturnsError

Geocache.cs changes:
- Refactored ProgramGeocache method: pin is no longer nullable, uses ClearGeocacheState helper, streamlined message assembly, added logging
- Added ClearGeocacheState private method
- Added EraseGeocache public method with detailed logging

* Examples Update - Add EraseGeocacheCommand and related functionality

- Added EraseGeocacheCommand to GeocacheViewModel in MauiAntGrpcClient and WpfUsbStickApp namespaces.
- Introduced EraseGeocache method in GeocacheViewModel to handle geocache erasure.
- Added CanEraseGeocache method to determine if EraseGeocacheCommand can be executed.
- Updated ProgramGeocacheView.xaml and GeocacheWindow.xaml to include buttons for erasing geocaches.
- Changed pin property type from uint? to uint in GeocacheViewModel.
- Added NotifyCanExecuteChangedFor attribute to isBusy property.

* Refactor geocache logic and improve logging

- Updated `EraseGeocache` test in `GeocacheTests.cs` to verify specific byte arrays.
- Removed retry logic in `SendExtAcknowledgedMessage` in `AntDevice.cs`; now logs a warning on failure.
- Refactored `RequestPinPage` in `Geocache.cs` to use new `ClearGeocacheState` method.
- Corrected typo in exception message in `UpdateLoggedVisits` in `Geocache.cs`.
- Updated logging in `ProgramGeocache` and `EraseGeocache` in `Geocache.cs` to use structured logging.

* Refactor methods and update logging in Ant classes

Renamed private methods and updated logging statements in the
AntChannel and AntRadio classes within the SmallEarthTech.AntUsbStick
namespace. Specifically:
- In AntChannel.cs:
  - Renamed Channel_ChannelResponse to OnChannelResponse.
  - Renamed Channel_DeviceNotification to OnDeviceNotification.
  - Changed logging level for OnChannelResponse from LogDebug to LogTrace.
  - Updated logging statements to use structured logging with named placeholders.
- In AntRadio.cs:
  - Renamed AntDevice_deviceResponse to OnDeviceResponse.
  - Renamed AntDevice_SerialError to OnAntDeviceSerialError.
  - Updated logging statements to use structured logging with named placeholders.

Updated AntUsbStick.csproj to upgrade Microsoft.Extensions.Logging.Abstractions
package from version 8.0.2 to 9.0.2.

* Clean up logging in various projects.

* Clean up logging.

* Project file updates for hosting and USB stick.

* Updated documentation project content.

Author: StephenHidem

AntPlus.Extensions.Hosting/Hosting.csproj

@@ -12,6 +12,8 @@
     <Description>Useful ANT+ extensions for hosting in DI containers. Simple and easy to use! Includes support for .NET MAUI and Windows apps.</Description>
     <PackageTags>ant; ant+; antplus; smallearthtech</PackageTags>
 	<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+	<PublishRepositoryUrl>true</PublishRepositoryUrl>
+	<EmbedUntrackedSources>true</EmbedUntrackedSources>
 	<PackageIcon>PackageLogo.png</PackageIcon>
 	<PackageReadmeFile>readme.md</PackageReadmeFile>
 	<PackageReleaseNotes>Fixed potential race condition sending multiple messages to multiple ANT devices managed by the AntCollection class.</PackageReleaseNotes>
@@ -20,6 +22,8 @@
 	<SymbolPackageFormat>snupkg</SymbolPackageFormat>
 	<AssemblyVersion>1.1.1.0</AssemblyVersion>
 	<Version>$(VersionPrefix)$(AssemblyVersion)</Version>
+	<PackageProjectUrl>https://stephenhidem.github.io/AntPlus</PackageProjectUrl>
+	<RepositoryUrl>https://github.com/StephenHidem/AntPlus</RepositoryUrl>
   </PropertyGroup>
 
   <ItemGroup>

AntPlus.Extensions.Hosting/SendMessageChannel.cs

@@ -85,11 +85,10 @@ public Task<MessagingReturnCode> SendExtAcknowledgedDataAsync(ChannelId channelI
                     .ContinueWith(antecedent =>
                     {
                         int index = antecedent.Result;
-                        _logger.LogDebug("SendExtAcknowledgedDataAsync: Invoke. Task ID = {TaskId}, channel index = {ChannelIndex}, channel ID = 0x{ChannelId:X8}", antecedent.Id, index, channelId.Id);
+                        _logger.LogDebug("SendExtAcknowledgedDataAsync: channel index = {ChannelIndex}, channel ID = 0x{ChannelId:X8}, data = {Data}", index, channelId.Id, BitConverter.ToString(data));
                         _channels[index].SendExtAcknowledgedDataAsync(channelId, data, ackWaitTime)
                         .ContinueWith(innerAntecedent =>
                         {
-                            _logger.LogDebug("SendExtAcknowledgedDataAsync: Completed. Task ID = {TaskId}, channel index = {ChannelIndex}, channel ID = 0x{ChannelId:X8}", antecedent.Id, index, channelId.Id);
                             lock (_channelLock)
                             {
                                 // release the channel and notify this channel is available

AntPlus.UnitTests/AntPlus.UnitTests.csproj

@@ -8,11 +8,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="Moq" Version="4.20.72" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.6.1" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.6.1" />
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="MSTest.TestAdapter" Version="3.7.3" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.7.3" />
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

AntPlus.UnitTests/DeviceProfiles/FitnessEquipment/TrainerStationaryBikeTests.cs

@@ -116,7 +116,7 @@ public async Task Parse_CalibrationResponse_Success(CalibrationRequestResponse r
             mockAntChannel.Setup(ac => ac.SendExtAcknowledgedDataAsync(
                 mockChannelId,
                 dataPage,
-                500).Result).Returns(MessagingReturnCode.Pass);
+                It.IsAny<uint>()).Result).Returns(MessagingReturnCode.Pass);
 
             // Act
             var result = await trainer.CalibrationRequest(request);
@@ -262,7 +262,7 @@ public async Task SetBasicResistance_Message_Matches()
             mockAntChannel.Setup(ac => ac.SendExtAcknowledgedDataAsync(
                 mockChannelId,
                 new byte[8] { 48, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, (byte)(resistance / 0.5) },
-                500).Result).Returns(MessagingReturnCode.Pass);
+                It.IsAny<uint>()).Result).Returns(MessagingReturnCode.Pass);
 
             // Act
             var result = await trainer.SetBasicResistance(
@@ -283,7 +283,7 @@ public async Task SetTargetPower_Message_Matches()
             mockAntChannel.Setup(ac => ac.SendExtAcknowledgedDataAsync(
                 mockChannelId,
                 new byte[8] { 49, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, expPow[0], expPow[1] },
-                500).Result).Returns(MessagingReturnCode.Pass);
+                It.IsAny<uint>()).Result).Returns(MessagingReturnCode.Pass);
 
             // Act
             var result = await trainer.SetTargetPower(
@@ -305,7 +305,7 @@ public async Task SetWindResistance_Message_Matches()
             mockAntChannel.Setup(ac => ac.SendExtAcknowledgedDataAsync(
                 mockChannelId,
                 new byte[8] { 50, 0xFF, 0xFF, 0xFF, 0xFF, (byte)(windResistanceCoefficient / 0.01), (byte)(windSpeed + 127), (byte)(draftingFactor / 0.01) },
-                500).Result).Returns(MessagingReturnCode.Pass);
+                It.IsAny<uint>()).Result).Returns(MessagingReturnCode.Pass);
 
             // Act
             var result = await trainer.SetWindResistance(
@@ -329,7 +329,7 @@ public async Task SetTrackResistance_Message_Matches()
             mockAntChannel.Setup(ac => ac.SendExtAcknowledgedDataAsync(
                 mockChannelId,
                 new byte[8] { 51, 0xFF, 0xFF, 0xFF, 0xFF, expGrade[0], expGrade[1], (byte)(rollingResistanceCoefficient / 0.00005) },
-                500).Result).Returns(MessagingReturnCode.Pass);
+                It.IsAny<uint>()).Result).Returns(MessagingReturnCode.Pass);
 
             // Act
             var result = await trainer.SetTrackResistance(
@@ -357,7 +357,7 @@ public async Task SetUserConfiguration_Message_Matches()
             mockAntChannel.Setup(ac => ac.SendExtAcknowledgedDataAsync(
                 mockChannelId,
                 new byte[8] { 55, expWeight[0], expWeight[1], 0xFF, (byte)((wheelDiameterOffset & 0x0F) | (expBikeWeight[0] & 0xF0)), expBikeWeight[1], (byte)(wheelDiameter / 0.01), (byte)(gearRatio / 0.03) },
-                500).Result).Returns(MessagingReturnCode.Pass);
+                It.IsAny<uint>()).Result).Returns(MessagingReturnCode.Pass);
 
             // Act
             var result = await trainer.SetUserConfiguration(

AntPlus.UnitTests/DeviceProfiles/GeocacheTests.cs

@@ -45,7 +45,7 @@ public void TestInitialize()
         {
             mockRepository = new MockRepository(MockBehavior.Strict);
 
-            mockAntChannel = mockRepository.Create<IAntChannel>();
+            mockAntChannel = mockRepository.Create<IAntChannel>(MockBehavior.Loose);
             mockLogger = mockRepository.Create<ILogger<Geocache>>(MockBehavior.Loose);
         }
 
@@ -175,5 +175,53 @@ public async Task ProgramGeocache_StateInitialize_StateCleared()
             Assert.AreEqual(default, geocache.NumberOfVisits);
             Assert.AreEqual(default, geocache.LastVisitTimestamp);
         }
+
+        [TestMethod]
+        public async Task EraseGeocache_Success_ReturnsPass()
+        {
+            // Arrange
+            mockAntChannel.Setup(ac => ac.SendExtAcknowledgedDataAsync(cid, It.IsAny<byte[]>(), It.IsAny<uint>()).Result)
+                .Returns(MessagingReturnCode.Pass);
+            Geocache geocache = new(cid, mockAntChannel.Object, mockLogger.Object, null);
+
+            // Act
+            var result = await geocache.EraseGeocache();
+
+            // Assert
+            Assert.AreEqual(MessagingReturnCode.Pass, result);
+            mockAntChannel.Verify(ac => ac.SendExtAcknowledgedDataAsync(
+                cid,
+                It.Is<byte[]>(msg =>
+                    msg.Length == 8 &&
+                    msg[0] == 0 &&
+                    msg.Skip(1).All(el => el == 0)),
+                It.IsAny<uint>()),
+                Times.Once);
+            mockAntChannel.Verify(ac => ac.SendExtAcknowledgedDataAsync(
+                cid,
+                It.Is<byte[]>(msg =>
+                    msg.Length == 8 &&
+                    msg[0] >= 1 && msg[0] <= 31 &&
+                    msg.Skip(1).All(el => el == 0xFF)),
+                It.IsAny<uint>()),
+                Times.Exactly(31));
+        }
+
+        [TestMethod]
+        public async Task EraseGeocache_Failure_ReturnsError()
+        {
+            // Arrange
+            mockAntChannel.SetupSequence(ac => ac.SendExtAcknowledgedDataAsync(cid, It.IsAny<byte[]>(), It.IsAny<uint>()).Result)
+                .Returns(MessagingReturnCode.Pass)
+                .Returns(MessagingReturnCode.Fail);
+            Geocache geocache = new(cid, mockAntChannel.Object, mockLogger.Object, null);
+
+            // Act
+            var result = await geocache.EraseGeocache();
+
+            // Assert
+            Assert.AreEqual(MessagingReturnCode.Fail, result);
+            mockAntChannel.Verify(ac => ac.SendExtAcknowledgedDataAsync(cid, It.IsAny<byte[]>(), It.IsAny<uint>()), Times.AtLeastOnce);
+        }
     }
 }

AntPlus/AntDevice.cs

@@ -127,21 +127,20 @@ public override string ToString()
         /// <summary>Requests the data page.</summary>
         /// <typeparam name="T">The data page enumeration of the derived ANT device class.</typeparam>
         /// <param name="page">The requested page.</param>
-        /// <param name="ackWaitTime">Time in milliseconds to wait for the device acknowledgment. The default is 500ms.</param>
         /// <param name="descriptor1">The descriptor1. The default is 0xFF.</param>
         /// <param name="descriptor2">The descriptor2. The default is 0xFF.</param>
         /// <param name="transmissionResponse">The transmission response. The default is to send 4 messages.</param>
         /// <param name="commandType">Type of the command. The default is <see cref="CommandType.DataPage"/>.</param>
         /// <param name="slaveSerialNumber">The slave serial number. The default is 0xFFFF.</param>
         /// <returns>Status of the request.</returns>
         /// <exception cref="System.ArgumentException">Invalid data page requested.</exception>
-        public async Task<MessagingReturnCode> RequestDataPage<T>(T page, uint ackWaitTime = 500, byte descriptor1 = 0xFF, byte descriptor2 = 0xFF, byte transmissionResponse = 4, CommandType commandType = CommandType.DataPage, ushort slaveSerialNumber = 0xFFFF) where T : Enum
+        public async Task<MessagingReturnCode> RequestDataPage<T>(T page, byte descriptor1 = 0xFF, byte descriptor2 = 0xFF, byte transmissionResponse = 4, CommandType commandType = CommandType.DataPage, ushort slaveSerialNumber = 0xFFFF) where T : Enum
         {
             if (Enum.IsDefined(typeof(T), page))
             {
                 byte[] msg = new byte[] { (byte)CommonDataPage.RequestDataPage, 0, 0, descriptor1, descriptor2, transmissionResponse, Convert.ToByte(page), (byte)commandType };
                 BitConverter.GetBytes(slaveSerialNumber).CopyTo(msg, 1);
-                return await _antChannel.SendExtAcknowledgedDataAsync(ChannelId, msg, ackWaitTime);
+                return await _antChannel.SendExtAcknowledgedDataAsync(ChannelId, msg, (uint)_deviceTimeout);
             }
             else
             {
@@ -153,16 +152,10 @@ public async Task<MessagingReturnCode> RequestDataPage<T>(T page, uint ackWaitTi
 
         /// <summary>Sends an acknowledged message to the ANT device.</summary>
         /// <param name="message">The message.</param>
-        /// <param name="ackWaitTime">Time in milliseconds to wait for the device acknowledgment. The default is 500ms.</param>
         /// <returns>Status of the request.</returns>
-        public async Task<MessagingReturnCode> SendExtAcknowledgedMessage(byte[] message, uint ackWaitTime = 500)
+        public async Task<MessagingReturnCode> SendExtAcknowledgedMessage(byte[] message)
         {
-            int retries = 3;
-            MessagingReturnCode ret;
-            do
-            {
-                ret = await _antChannel.SendExtAcknowledgedDataAsync(ChannelId, message, ackWaitTime);
-            } while (ret != MessagingReturnCode.Pass && --retries > 0);
+            MessagingReturnCode ret = await _antChannel.SendExtAcknowledgedDataAsync(ChannelId, message, (uint)_deviceTimeout);
 
             if (ret != MessagingReturnCode.Pass)
             {

AntPlus/DeviceProfiles/AssetTracker/Tracker.cs

@@ -138,7 +138,7 @@ internal Asset GetAsset(byte[] data)
                 {
                     Assets.Add(asset);
                 }
-                _ = RequestDataPage(DataPage.AssetId1, 500, 255, 255, 4, CommandType.DataPageSet);
+                _ = RequestDataPage(DataPage.AssetId1, 255, 255, 4, CommandType.DataPageSet);
             }
             return asset;
         }

AntPlus/DeviceProfiles/BicyclePower/Parameters.cs

@@ -263,7 +263,7 @@ private void ParseParameters(byte[] dataPage)
         /// <returns>Status of the request.</returns>
         public async Task<MessagingReturnCode> GetParameters(SubPage parameterSubpage)
         {
-            return await RequestDataPage(DataPage.GetSetParameters, 500, (byte)parameterSubpage);
+            return await RequestDataPage(DataPage.GetSetParameters, (byte)parameterSubpage);
         }
 
         /// <summary>