Improve conection stability & reconnection logic

WentTheFox · WentTheFox · commit ce87cb71388f · 2023-10-06T19:56:09.000+02:00
Closes #3 Closes #4
diff --git a/BluetoothHeartrateModule/BluetoothHeartrateModule.cs b/BluetoothHeartrateModule/BluetoothHeartrateModule.cs
@@ -19,7 +19,6 @@ public BluetoothHeartrateModule()
 
         protected override BluetoothHeartrateProvider CreateProvider()
         {
-            watcher = new BluetoothLEAdvertisementWatcher { ScanningMode = BluetoothLEScanningMode.Active };
             var provider = new BluetoothHeartrateProvider(this);
             provider.OnHeartrateUpdate += SendWebcoketHeartrate;
             return provider;
@@ -44,15 +43,21 @@ protected override void CreateAttributes()
 
         protected override async void OnModuleStart()
         {
-            ResetWatcher();
+            CreateWatcher();
             base.OnModuleStart();
-            await wsServer.Start();
+            if (GetWebocketEnabledSetting())
+            {
+                await wsServer.Start();
+            }
         }
 
         protected override void OnModuleStop()
         {
-            ResetWatcher();
-            wsServer.Stop();
+            StopWatcher();
+            if (GetWebocketEnabledSetting())
+            {
+                wsServer.Stop();
+            }
             base.OnModuleStop();
         }
 
@@ -73,30 +78,71 @@ internal int GetWebocketPortSetting()
             return GetSetting<int>(BluetoothHeartrateSetting.WebsocketServerPort);
         }
 
-        internal void StopWatcher()
-        {
-            watcher?.Stop();
-        }
-
         internal void SetDeviceName(string deviceName)
         {
             SetVariableValue(BluetoothHeartratevariable.DeviceName, deviceName);
         }
 
         private async void SendWebcoketHeartrate(int heartrate)
         {
+            if (!GetWebocketEnabledSetting())
+            {
+                return;
+            }
+
             await wsServer.SendIntMessage(heartrate);
         }
+        internal BluetoothLEAdvertisementWatcher CreateWatcher()
+        {
+            if (watcher == null)
+            {
+                watcher = new BluetoothLEAdvertisementWatcher { ScanningMode = BluetoothLEScanningMode.Active };
+                watcher.Stopped += Watcher_Stopped;
+            }
+            return watcher;
+        }
+
+        private void Watcher_Stopped(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementWatcherStoppedEventArgs args)
+        {
+            string scanStatus;
+            bool invokeDisconnect = true;
+            switch (args.Error)
+            {
+                case Windows.Devices.Bluetooth.BluetoothError.RadioNotAvailable:
+                    scanStatus = "Bluetooth adapter/module is disconnected";
+                    break;
+                case Windows.Devices.Bluetooth.BluetoothError.Success:
+                    scanStatus = "device found";
+                    invokeDisconnect = false;
+                    break;
+                default:
+                    scanStatus = args.Error.ToString();
+                    break;
+            }
+            Log($"Stopped scanning for devices ({scanStatus})");
+            if (invokeDisconnect)
+            {
+                HeartrateProvider?.OnDisconnected?.Invoke();
+            }
+        }
 
-        private void ResetWatcher()
+        internal void StartWatcher()
         {
             if (watcher != null)
             {
-                StopWatcher();
-                watcher = null;
+                if (watcher.Status != BluetoothLEAdvertisementWatcherStatus.Started)
+                {
+                    watcher.Start();
+                    Log("Scanning for devices");
+                }
             }
         }
 
+        internal void StopWatcher()
+        {
+            watcher?.Stop();
+        }
+
         internal enum BluetoothHeartrateSetting
         {
             DeviceMac,
diff --git a/BluetoothHeartrateModule/BluetoothHeartrateModule.csproj b/BluetoothHeartrateModule/BluetoothHeartrateModule.csproj
@@ -4,8 +4,8 @@
 		<TargetFramework>net6.0-windows10.0.22621.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
-		<AssemblyVersion>1.3.2</AssemblyVersion>
-		<FileVersion>1.3.2</FileVersion>
+		<AssemblyVersion>1.3.3</AssemblyVersion>
+		<FileVersion>1.3.3</FileVersion>
 		<Authors>DJDavid98</Authors>
 		<Product>Bluetooth Heartrate</Product>
 		<ApplicationIcon>logo\logo.ico</ApplicationIcon>
diff --git a/BluetoothHeartrateModule/BluetoothHeartrateProvider.cs b/BluetoothHeartrateModule/BluetoothHeartrateProvider.cs
@@ -9,16 +9,18 @@ namespace BluetoothHeartrateModule
     public class BluetoothHeartrateProvider : HeartrateProvider
     {
         private Dictionary<string, string?> deviceNames = new();
+        private GattDeviceService? heartRateService;
         private GattCharacteristic? heartRateCharacteristic;
         private HashSet<string> missingCharacteristicDevices = new();
         private bool processingData = false;
         BluetoothLEDevice? currentDevice;
         private readonly BluetoothHeartrateModule module;
-        public override bool IsConnected => currentDevice != null && heartRateCharacteristic != null;
+        public override bool IsConnected => currentDevice != null && heartRateCharacteristic != null && currentDevice.ConnectionStatus == BluetoothConnectionStatus.Connected;
 
         public BluetoothHeartrateProvider(BluetoothHeartrateModule module)
         {
             this.module = module;
+
         }
 
         public override void Initialise()
@@ -35,15 +37,7 @@ public override void Initialise()
             }
 
             module.watcher.Received += Watcher_Received;
-            module.watcher.Stopped += Watcher_Stopped;
-            switch (module.watcher.Status)
-            {
-                case BluetoothLEAdvertisementWatcherStatus.Stopped:
-                case BluetoothLEAdvertisementWatcherStatus.Created:
-                    module.watcher.Start();
-                    Log("Watching for devices");
-                    break;
-            }
+            module.StartWatcher();
         }
 
 #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
@@ -59,24 +53,50 @@ private void Reset()
             if (module.watcher != null)
             {
                 module.watcher.Received -= Watcher_Received;
-                module.watcher.Stopped -= Watcher_Stopped;
             }
             deviceNames.Clear();
             missingCharacteristicDevices.Clear();
             ResetDevice();
             processingData = false;
         }
 
-        private void ResetDevice()
+        private async void ResetDevice()
         {
+            if (heartRateService != null)
+            {
+                try
+                {
+                    heartRateService.Dispose();
+                }
+                catch (ObjectDisposedException)
+                {
+                    // Ignore if object is already disposed
+                }
+                heartRateService = null;
+            }
             if (heartRateCharacteristic != null)
             {
-                heartRateCharacteristic.ValueChanged -= HeartRateCharacteristic_ValueChanged;
+                try
+                {
+                    heartRateCharacteristic.ValueChanged -= HeartRateCharacteristic_ValueChanged;
+                }
+                catch (ObjectDisposedException)
+                {
+                    // Ignore if object is already disposed
+                }
                 heartRateCharacteristic = null;
             }
             if (currentDevice != null)
             {
-                currentDevice.Dispose();
+                try
+                {
+                    currentDevice.ConnectionStatusChanged -= Device_ConnectionStatusChanged;
+                    currentDevice.Dispose();
+                }
+                catch (ObjectDisposedException)
+                {
+                    // Ignore if object is already disposed
+                }
                 currentDevice = null;
             }
         }
@@ -128,13 +148,15 @@ private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, Blue
                     var currentDeviceName = deviceNames[advertisementMac] ?? "Unknown";
                     Log($"Found device named {currentDeviceName} for MAC {advertisementMac}");
                     module.SetDeviceName(currentDeviceName);
+                    currentDevice.ConnectionStatusChanged += Device_ConnectionStatusChanged;
                 }
 
                 var missungUnknown = !missingCharacteristicDevices.Contains(deviceMacSetting);
                 var services = await currentDevice.GetGattServicesForUuidAsync(GattServiceUuids.HeartRate, BluetoothCacheMode.Uncached);
                 if (services.Services.Count > 0)
                 {
-                    var firstService = services.Services[0];
+                    IEnumerable<GattDeviceService> cleanupServices = services.Services;
+                    var firstService = cleanupServices.First();
                     if (missungUnknown)
                     {
                         Log("Found heartrate service");
@@ -144,6 +166,7 @@ private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, Blue
                     {
                         if (heartRateCharacteristic == null)
                         {
+                            heartRateService = firstService;
                             heartRateCharacteristic = characteristics.Characteristics[0];
                             Log("Found heartrate measurement characteristic");
 
@@ -162,16 +185,19 @@ private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, Blue
                                 }
                                 OnConnected?.Invoke();
                                 Log("Connection successful");
+                                module.StopWatcher();
+                                cleanupServices = services.Services.Skip(1);
                             }
                             else
                             {
                                 Log($"Failed to enable heart rate notifications. Status: {status}");
                             }
                         }
                     }
-                    else
+
+                    if (cleanupServices.Any())
                     {
-                        foreach (var service in services.Services)
+                        foreach (var service in cleanupServices)
                             service.Dispose();
                     }
                 }
@@ -201,10 +227,13 @@ private void HeartRateCharacteristic_ValueChanged(GattCharacteristic sender, Gat
             OnHeartrateUpdate?.Invoke(data[1]);
         }
 
-        private void Watcher_Stopped(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementWatcherStoppedEventArgs args)
+        private async void Device_ConnectionStatusChanged(BluetoothLEDevice sender, object args)
         {
-            Log("Watcher stopped");
-            OnDisconnected?.Invoke();
+            if (sender.ConnectionStatus == BluetoothConnectionStatus.Disconnected)
+            {
+                Log("Current device disconected");
+                OnDisconnected?.Invoke();
+            }
         }
     }
 }
diff --git a/BluetoothHeartrateModule/WebsocketHeartrateServer.cs b/BluetoothHeartrateModule/WebsocketHeartrateServer.cs
@@ -109,12 +109,6 @@ private void StopHttpListener()
         // Public method to send an int message to all clients
         internal async Task SendIntMessage(int message)
         {
-            if (!module.GetWebocketEnabledSetting())
-            {
-                Stop();
-                return;
-            }
-
             var messageBuffer = new ArraySegment<byte>(Converter.GetAsciiStringInt(message));
             foreach (var clientId in connectedClients.Keys)
             {

Original file line number	Diff line number	Diff line change
`@@ -9,16 +9,18 @@ namespace BluetoothHeartrateModule`
`9`	`9`	`public class BluetoothHeartrateProvider : HeartrateProvider`
`10`	`10`	`{`
`11`	`11`	`private Dictionary<string, string?> deviceNames = new();`
	`12`	`+ private GattDeviceService? heartRateService;`
`12`	`13`	`private GattCharacteristic? heartRateCharacteristic;`
`13`	`14`	`private HashSet<string> missingCharacteristicDevices = new();`
`14`	`15`	`private bool processingData = false;`
`15`	`16`	`BluetoothLEDevice? currentDevice;`
`16`	`17`	`private readonly BluetoothHeartrateModule module;`
`17`		`- public override bool IsConnected => currentDevice != null && heartRateCharacteristic != null;`
	`18`	`+ public override bool IsConnected => currentDevice != null && heartRateCharacteristic != null && currentDevice.ConnectionStatus == BluetoothConnectionStatus.Connected;`
`18`	`19`
`19`	`20`	`public BluetoothHeartrateProvider(BluetoothHeartrateModule module)`
`20`	`21`	`{`
`21`	`22`	`this.module = module;`
	`23`	`+`
`22`	`24`	`}`
`23`	`25`
`24`	`26`	`public override void Initialise()`
`@@ -35,15 +37,7 @@ public override void Initialise()`
`35`	`37`	`}`
`36`	`38`
`37`	`39`	`module.watcher.Received += Watcher_Received;`
`38`		`- module.watcher.Stopped += Watcher_Stopped;`
`39`		`- switch (module.watcher.Status)`
`40`		`- {`
`41`		`- case BluetoothLEAdvertisementWatcherStatus.Stopped:`
`42`		`- case BluetoothLEAdvertisementWatcherStatus.Created:`
`43`		`- module.watcher.Start();`
`44`		`- Log("Watching for devices");`
`45`		`- break;`
`46`		`- }`
	`40`	`+ module.StartWatcher();`
`47`	`41`	`}`
`48`	`42`
`49`	`43`	`#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously`
`@@ -59,24 +53,50 @@ private void Reset()`
`59`	`53`	`if (module.watcher != null)`
`60`	`54`	`{`
`61`	`55`	`module.watcher.Received -= Watcher_Received;`
`62`		`- module.watcher.Stopped -= Watcher_Stopped;`
`63`	`56`	`}`
`64`	`57`	`deviceNames.Clear();`
`65`	`58`	`missingCharacteristicDevices.Clear();`
`66`	`59`	`ResetDevice();`
`67`	`60`	`processingData = false;`
`68`	`61`	`}`
`69`	`62`
`70`		`- private void ResetDevice()`
	`63`	`+ private async void ResetDevice()`
`71`	`64`	`{`
	`65`	`+ if (heartRateService != null)`
	`66`	`+ {`
	`67`	`+ try`
	`68`	`+ {`
	`69`	`+ heartRateService.Dispose();`
	`70`	`+ }`
	`71`	`+ catch (ObjectDisposedException)`
	`72`	`+ {`
	`73`	`+ // Ignore if object is already disposed`
	`74`	`+ }`
	`75`	`+ heartRateService = null;`
	`76`	`+ }`
`72`	`77`	`if (heartRateCharacteristic != null)`
`73`	`78`	`{`
`74`		`- heartRateCharacteristic.ValueChanged -= HeartRateCharacteristic_ValueChanged;`
	`79`	`+ try`
	`80`	`+ {`
	`81`	`+ heartRateCharacteristic.ValueChanged -= HeartRateCharacteristic_ValueChanged;`
	`82`	`+ }`
	`83`	`+ catch (ObjectDisposedException)`
	`84`	`+ {`
	`85`	`+ // Ignore if object is already disposed`
	`86`	`+ }`
`75`	`87`	`heartRateCharacteristic = null;`
`76`	`88`	`}`
`77`	`89`	`if (currentDevice != null)`
`78`	`90`	`{`
`79`		`- currentDevice.Dispose();`
	`91`	`+ try`
	`92`	`+ {`
	`93`	`+ currentDevice.ConnectionStatusChanged -= Device_ConnectionStatusChanged;`
	`94`	`+ currentDevice.Dispose();`
	`95`	`+ }`
	`96`	`+ catch (ObjectDisposedException)`
	`97`	`+ {`
	`98`	`+ // Ignore if object is already disposed`
	`99`	`+ }`
`80`	`100`	`currentDevice = null;`
`81`	`101`	`}`
`82`	`102`	`}`
`@@ -128,13 +148,15 @@ private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, Blue`
`128`	`148`	`var currentDeviceName = deviceNames[advertisementMac] ?? "Unknown";`
`129`	`149`	`Log($"Found device named {currentDeviceName} for MAC {advertisementMac}");`
`130`	`150`	`module.SetDeviceName(currentDeviceName);`
	`151`	`+ currentDevice.ConnectionStatusChanged += Device_ConnectionStatusChanged;`
`131`	`152`	`}`
`132`	`153`
`133`	`154`	`var missungUnknown = !missingCharacteristicDevices.Contains(deviceMacSetting);`
`134`	`155`	`var services = await currentDevice.GetGattServicesForUuidAsync(GattServiceUuids.HeartRate, BluetoothCacheMode.Uncached);`
`135`	`156`	`if (services.Services.Count > 0)`
`136`	`157`	`{`
`137`		`- var firstService = services.Services[0];`
	`158`	`+ IEnumerable<GattDeviceService> cleanupServices = services.Services;`
	`159`	`+ var firstService = cleanupServices.First();`
`138`	`160`	`if (missungUnknown)`
`139`	`161`	`{`
`140`	`162`	`Log("Found heartrate service");`
`@@ -144,6 +166,7 @@ private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, Blue`
`144`	`166`	`{`
`145`	`167`	`if (heartRateCharacteristic == null)`
`146`	`168`	`{`
	`169`	`+ heartRateService = firstService;`
`147`	`170`	`heartRateCharacteristic = characteristics.Characteristics[0];`
`148`	`171`	`Log("Found heartrate measurement characteristic");`
`149`	`172`
`@@ -162,16 +185,19 @@ private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, Blue`
`162`	`185`	`}`
`163`	`186`	`OnConnected?.Invoke();`
`164`	`187`	`Log("Connection successful");`
	`188`	`+ module.StopWatcher();`
	`189`	`+ cleanupServices = services.Services.Skip(1);`
`165`	`190`	`}`
`166`	`191`	`else`
`167`	`192`	`{`
`168`	`193`	`Log($"Failed to enable heart rate notifications. Status: {status}");`
`169`	`194`	`}`
`170`	`195`	`}`
`171`	`196`	`}`
`172`		`- else`
	`197`	`+`
	`198`	`+ if (cleanupServices.Any())`
`173`	`199`	`{`
`174`		`- foreach (var service in services.Services)`
	`200`	`+ foreach (var service in cleanupServices)`
`175`	`201`	`service.Dispose();`
`176`	`202`	`}`
`177`	`203`	`}`
`@@ -201,10 +227,13 @@ private void HeartRateCharacteristic_ValueChanged(GattCharacteristic sender, Gat`
`201`	`227`	`OnHeartrateUpdate?.Invoke(data[1]);`
`202`	`228`	`}`
`203`	`229`
`204`		`- private void Watcher_Stopped(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementWatcherStoppedEventArgs args)`
	`230`	`+ private async void Device_ConnectionStatusChanged(BluetoothLEDevice sender, object args)`
`205`	`231`	`{`
`206`		`- Log("Watcher stopped");`
`207`		`- OnDisconnected?.Invoke();`
	`232`	`+ if (sender.ConnectionStatus == BluetoothConnectionStatus.Disconnected)`
	`233`	`+ {`
	`234`	`+ Log("Current device disconected");`
	`235`	`+ OnDisconnected?.Invoke();`
	`236`	`+ }`
`208`	`237`	`}`
`209`	`238`	`}`
`210`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -109,12 +109,6 @@ private void StopHttpListener()`
`109`	`109`	`// Public method to send an int message to all clients`
`110`	`110`	`internal async Task SendIntMessage(int message)`
`111`	`111`	`{`
`112`		`- if (!module.GetWebocketEnabledSetting())`
`113`		`- {`
`114`		`- Stop();`
`115`		`- return;`
`116`		`- }`
`117`		`-`
`118`	`112`	`var messageBuffer = new ArraySegment<byte>(Converter.GetAsciiStringInt(message));`
`119`	`113`	`foreach (var clientId in connectedClients.Keys)`
`120`	`114`	`{`