ble: fix some issues in connect and disconnect (hybridgroup#1161)

Author: gen2thomas

platforms/bleclient/ble_client_adaptor.go

@@ -12,9 +12,10 @@ import (
 )
 
 type configuration struct {
-	scanTimeout          time.Duration
-	sleepAfterDisconnect time.Duration
-	debug                bool
+	scanTimeout                     time.Duration
+	sleepAfterDisconnect            time.Duration
+	dropCharacteristicsOnDisconnect bool
+	debug                           bool
 }
 
 // Adaptor represents a Client Connection to a BLE Peripheral
@@ -38,8 +39,9 @@ type Adaptor struct {
 //
 // Supported options:
 //
-//	"WithAdaptorDebug"
-//	"WithAdaptorScanTimeout"
+//	"WithDebug"
+//	"WithDropCharacteristicsOnDisconnect"
+//	"WithScanTimeout"
 func NewAdaptor(identifier string, opts ...optionApplier) *Adaptor {
 	cfg := configuration{
 		scanTimeout:          10 * time.Minute,
@@ -67,6 +69,13 @@ func WithDebug() debugOption {
 	return debugOption(true)
 }
 
+// WithWithDropCharacteristicsOnDisconnect leads to clean all discovered services from last connect command if a
+// disconnect command happen. Also all subscriptions will be cleaned. A new discover of services and characteristics is
+// done on next connect and the subscriptions needs to be done again afterwards by the caller.
+func WithDropCharacteristicsOnDisconnect() dropCharacteristicsOnDisconnect {
+	return dropCharacteristicsOnDisconnect(true)
+}
+
 // WithScanTimeout substitute the default scan timeout of 10 min.
 func WithScanTimeout(timeout time.Duration) scanTimeoutOption {
 	return scanTimeoutOption(timeout)
@@ -104,6 +113,10 @@ func (a *Adaptor) Connect() error {
 	a.mutex.Lock()
 	defer a.mutex.Unlock()
 
+	if a.connected {
+		return fmt.Errorf("%s is already connected", a.name)
+	}
+
 	var err error
 
 	if a.cfg.debug {
@@ -139,28 +152,30 @@ func (a *Adaptor) Connect() error {
 	a.rssi = int(result.RSSI)
 	a.btDevice = dev
 
-	if a.cfg.debug {
-		fmt.Println("[Connect]: get all services/characteristics...")
-	}
-	services, err := a.btDevice.discoverServices(nil)
-	if err != nil {
-		return err
-	}
-	for _, service := range services {
+	if len(a.characteristics) == 0 {
 		if a.cfg.debug {
-			fmt.Printf("[Connect]: service found: %s\n", service)
+			fmt.Println("[Connect]: get all services/characteristics...")
 		}
-		chars, err := service.DiscoverCharacteristics(nil)
+		services, err := a.btDevice.discoverServices(nil)
 		if err != nil {
-			log.Println(err)
-			continue
+			return err
 		}
-		for _, char := range chars {
+		for _, service := range services {
 			if a.cfg.debug {
-				fmt.Printf("[Connect]: characteristic found: %s\n", char)
+				fmt.Printf("[Connect]: service found: %s\n", service)
+			}
+			chars, err := service.DiscoverCharacteristics(nil)
+			if err != nil {
+				log.Println(err)
+				continue
+			}
+			for _, char := range chars {
+				if a.cfg.debug {
+					fmt.Printf("[Connect]: characteristic found: %s\n", char)
+				}
+				c := char // to prevent implicit memory aliasing in for loop, before go 1.22
+				a.characteristics[char.UUID().String()] = &c
 			}
-			c := char // to prevent implicit memory aliasing in for loop, before go 1.22
-			a.characteristics[char.UUID().String()] = &c
 		}
 	}
 
@@ -187,6 +202,26 @@ func (a *Adaptor) Disconnect() error {
 	if a.cfg.debug {
 		fmt.Println("[Disconnect]: disconnect...")
 	}
+
+	if a.cfg.dropCharacteristicsOnDisconnect {
+		if a.cfg.debug {
+			fmt.Println("[Disconnect]: unsubscribe...")
+		}
+
+		for id, chara := range a.characteristics {
+			if err := adjustNotificationsForCharacteristic(chara, nil); err != nil {
+				fmt.Printf("[Disconnect]: error on unsubscribe characteristic %s: %v\n", id, err)
+			}
+		}
+
+		if a.cfg.debug {
+			fmt.Println("[Disconnect]: drop characteristics...")
+		}
+		a.characteristics = make(map[string]bluetoothExtCharacteristicer)
+	} else if a.cfg.debug {
+		fmt.Println("[Disconnect]: as configured, characteristics not dropped")
+	}
+
 	err := a.btDevice.disconnect()
 	time.Sleep(a.cfg.sleepAfterDisconnect)
 	a.connected = false
@@ -252,7 +287,26 @@ func (a *Adaptor) Subscribe(cUUID string, f func(data []byte)) error {
 	}
 
 	if chara, ok := a.characteristics[cUUID]; ok {
-		return enableNotificationsForCharacteristic(chara, f)
+		return adjustNotificationsForCharacteristic(chara, f)
+	}
+
+	return fmt.Errorf("unknown characteristic: %s", cUUID)
+}
+
+// Unsubscribe remove subscription to notifications from the BLE device for the requested characteristic UUID.
+// The UUID can be given as 16-bit or 128-bit (with or without dashes) value.
+func (a *Adaptor) Unsubscribe(cUUID string) error {
+	if !a.connected {
+		return fmt.Errorf("cannot unsubscribe from BLE device until connected")
+	}
+
+	cUUID, err := convertUUID(cUUID)
+	if err != nil {
+		return err
+	}
+
+	if chara, ok := a.characteristics[cUUID]; ok {
+		return adjustNotificationsForCharacteristic(chara, nil)
 	}
 
 	return fmt.Errorf("unknown characteristic: %s", cUUID)

platforms/bleclient/ble_client_adaptor_options.go

@@ -7,12 +7,19 @@ type optionApplier interface {
 	apply(cfg *configuration)
 }
 
+// dropCharacteristicsOnDisconnect is the type for applying drop feature.
+type dropCharacteristicsOnDisconnect bool
+
 // debugOption is the type for applying the debug switch on or off.
 type debugOption bool
 
 // scanTimeoutOption is the type for applying another timeout than the default 10 min.
 type scanTimeoutOption time.Duration
 
+func (o dropCharacteristicsOnDisconnect) String() string {
+	return "drop characteristics on disconnect option for BLE client adaptors"
+}
+
 func (o debugOption) String() string {
 	return "debug option for BLE client adaptors"
 }
@@ -21,6 +28,10 @@ func (o scanTimeoutOption) String() string {
 	return "scan timeout option for BLE client adaptors"
 }
 
+func (o dropCharacteristicsOnDisconnect) apply(cfg *configuration) {
+	cfg.dropCharacteristicsOnDisconnect = bool(o)
+}
+
 func (o debugOption) apply(cfg *configuration) {
 	cfg.debug = bool(o)
 }

platforms/bleclient/ble_client_adaptor_options_test.go

@@ -16,6 +16,15 @@ func TestWithDebug(t *testing.T) {
 	assert.True(t, a.cfg.debug)
 }
 
+func TestWithDropCharacteristicsOnDisconnect(t *testing.T) {
+	// arrange
+	cfg := &configuration{dropCharacteristicsOnDisconnect: false}
+	// act
+	WithDropCharacteristicsOnDisconnect().apply(cfg)
+	// assert
+	assert.True(t, cfg.dropCharacteristicsOnDisconnect)
+}
+
 func TestWithScanTimeout(t *testing.T) {
 	// arrange
 	newTimeout := 2 * time.Second