WIP all: make Device a value instead of a pointer

This is a refactor that is necessary to make it easier to work with
connected central devices on a SoftDevice.

Author: aykevl

examples/discover/main.go

@@ -44,7 +44,7 @@ func main() {
 		}
 	})
 
-	var device *bluetooth.Device
+	var device bluetooth.Device
 	select {
 	case result := <-ch:
 		device, err = adapter.Connect(result.Address, bluetooth.ConnectionParams{})

examples/heartrate-monitor/main.go

@@ -52,7 +52,7 @@ func main() {
 		}
 	})
 
-	var device *bluetooth.Device
+	var device bluetooth.Device
 	select {
 	case result := <-ch:
 		device, err = adapter.Connect(result.Address, bluetooth.ConnectionParams{})

gap_darwin.go

@@ -85,6 +85,10 @@ func (a *Adapter) StopScan() error {
 
 // Device is a connection to a remote peripheral.
 type Device struct {
+	*deviceInternal
+}
+
+type deviceInternal struct {
 	delegate *peripheralDelegate
 
 	cm   cbgo.CentralManager
@@ -97,14 +101,14 @@ type Device struct {
 }
 
 // Connect starts a connection attempt to the given peripheral device address.
-func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, error) {
+func (a *Adapter) Connect(address Address, params ConnectionParams) (Device, error) {
 	uuid, err := cbgo.ParseUUID(address.UUID.String())
 	if err != nil {
-		return nil, err
+		return Device{}, err
 	}
 	prphs := a.cm.RetrievePeripheralsWithIdentifiers([]cbgo.UUID{uuid})
 	if len(prphs) == 0 {
-		return nil, fmt.Errorf("Connect failed: no peer with address: %s", address.UUID.String())
+		return Device{}, fmt.Errorf("Connect failed: no peer with address: %s", address.UUID.String())
 	}
 
 	timeout := defaultConnectionTimeout
@@ -129,14 +133,16 @@ func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, er
 
 			// check if we have received a disconnected peripheral
 			if p.State() == cbgo.PeripheralStateDisconnected {
-				return nil, connectionError
+				return Device{}, connectionError
 			}
 
-			d := &Device{
-				cm:           a.cm,
-				prph:         p,
-				servicesChan: make(chan error),
-				charsChan:    make(chan error),
+			d := Device{
+				&deviceInternal{
+					cm:           a.cm,
+					prph:         p,
+					servicesChan: make(chan error),
+					charsChan:    make(chan error),
+				},
 			}
 
 			d.delegate = &peripheralDelegate{d: d}
@@ -162,7 +168,7 @@ func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, er
 
 // Disconnect from the BLE device. This method is non-blocking and does not
 // wait until the connection is fully gone.
-func (d *Device) Disconnect() error {
+func (d Device) Disconnect() error {
 	d.cm.CancelConnect(d.prph)
 	return nil
 }
@@ -172,7 +178,7 @@ func (d *Device) Disconnect() error {
 type peripheralDelegate struct {
 	cbgo.PeripheralDelegateBase
 
-	d *Device
+	d Device
 }
 
 // DidDiscoverServices is called when the services for a Peripheral

gap_linux.go

@@ -272,6 +272,10 @@ func makeScanResult(props *device.Device1Properties) ScanResult {
 
 // Device is a connection to a remote peripheral.
 type Device struct {
+	*deviceInternal
+}
+
+type deviceInternal struct {
 	device      *device.Device1             // bluez device interface
 	ctx         context.Context             // context for our event watcher, canceled on disconnect event
 	cancel      context.CancelFunc          // cancel function to halt our event watcher context
@@ -283,17 +287,19 @@ type Device struct {
 // Connect starts a connection attempt to the given peripheral device address.
 //
 // On Linux and Windows, the IsRandom part of the address is ignored.
-func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, error) {
+func (a *Adapter) Connect(address Address, params ConnectionParams) (Device, error) {
 	devicePath := dbus.ObjectPath(string(a.adapter.Path()) + "/dev_" + strings.Replace(address.MAC.String(), ":", "_", -1))
 	dev, err := device.NewDevice1(devicePath)
 	if err != nil {
-		return nil, err
+		return Device{}, err
 	}
 
-	device := &Device{
-		device:  dev,
-		adapter: a,
-		address: address,
+	device := Device{
+		&deviceInternal{
+			device:  dev,
+			adapter: a,
+			address: address,
+		},
 	}
 	device.ctx, device.cancel = context.WithCancel(context.Background())
 	device.watchForConnect() // Set this up before we trigger a connection so we can capture the connect event
@@ -304,7 +310,7 @@ func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, er
 		err := dev.Connect()
 		if err != nil {
 			device.cancel() // cancel our watcher routine
-			return nil, err
+			return Device{}, err
 		}
 	}
 
@@ -313,7 +319,7 @@ func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, er
 
 // Disconnect from the BLE device. This method is non-blocking and does not
 // wait until the connection is fully gone.
-func (d *Device) Disconnect() error {
+func (d Device) Disconnect() error {
 	// we don't call our cancel function here, instead we wait for the
 	// property change in `watchForConnect` and cancel things then
 	return d.device.Disconnect()
@@ -323,7 +329,7 @@ func (d *Device) Disconnect() error {
 //
 // We can add extra signals to watch for here,
 // see https://git.kernel.org/pub/scm/bluetooth/bluez.git/tree/doc/device-api.txt, for a full list
-func (d *Device) watchForConnect() error {
+func (d Device) watchForConnect() error {
 	var err error
 	d.propchanged, err = d.device.WatchProperties()
 	if err != nil {

gap_nrf528xx-central.go

@@ -109,7 +109,7 @@ var connectionAttempt struct {
 // connection attempt at once and that the address parameter must have the
 // IsRandom bit set correctly. This bit is set correctly for scan results, so
 // you can reuse that address directly.
-func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, error) {
+func (a *Adapter) Connect(address Address, params ConnectionParams) (Device, error) {
 	// Construct an address object as used in the SoftDevice.
 	var addr C.ble_gap_addr_t
 	addr.addr = makeSDAddress(address.MAC)
@@ -158,15 +158,15 @@ func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, er
 	// This should be safe as long as Connect is not called concurrently. And
 	// even then, it should catch most such race conditions.
 	if connectionAttempt.state.Get() != 0 {
-		return nil, errAlreadyConnecting
+		return Device{}, errAlreadyConnecting
 	}
 	connectionAttempt.state.Set(1)
 
 	// Start the connection attempt. We'll get a signal in the event handler.
 	errCode := C.sd_ble_gap_connect(&addr, &scanParams, &connectionParams, C.BLE_CONN_CFG_TAG_DEFAULT)
 	if errCode != 0 {
 		connectionAttempt.state.Set(0)
-		return nil, Error(errCode)
+		return Device{}, Error(errCode)
 	}
 
 	// Wait until the connection is established.
@@ -179,13 +179,13 @@ func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, er
 	connectionAttempt.state.Set(0)
 
 	// Connection has been established.
-	return &Device{
+	return Device{
 		connectionHandle: connectionHandle,
 	}, nil
 }
 
 // Disconnect from the BLE device.
-func (d *Device) Disconnect() error {
+func (d Device) Disconnect() error {
 	errCode := C.sd_ble_gap_disconnect(d.connectionHandle, C.BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION)
 	if errCode != 0 {
 		return Error(errCode)

gap_windows.go

@@ -170,7 +170,7 @@ type Device struct {
 // Connect starts a connection attempt to the given peripheral device address.
 //
 // On Linux and Windows, the IsRandom part of the address is ignored.
-func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, error) {
+func (a *Adapter) Connect(address Address, params ConnectionParams) (Device, error) {
 	var winAddr uint64
 	for i := range address.MAC {
 		winAddr += uint64(address.MAC[i]) << (8 * i)
@@ -179,23 +179,23 @@ func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, er
 	// IAsyncOperation<BluetoothLEDevice>
 	bleDeviceOp, err := bluetooth.FromBluetoothAddressAsync(winAddr)
 	if err != nil {
-		return nil, err
+		return Device{}, err
 	}
 
 	// We need to pass the signature of the parameter returned by the async operation:
 	// IAsyncOperation<BluetoothLEDevice>
 	if err := awaitAsyncOperation(bleDeviceOp, bluetooth.SignatureBluetoothLEDevice); err != nil {
-		return nil, fmt.Errorf("error connecting to device: %w", err)
+		return Device{}, fmt.Errorf("error connecting to device: %w", err)
 	}
 
 	res, err := bleDeviceOp.GetResults()
 	if err != nil {
-		return nil, err
+		return Device{}, err
 	}
 
 	// The returned BluetoothLEDevice is set to null if FromBluetoothAddressAsync can't find the device identified by bluetoothAddress
 	if uintptr(res) == 0x0 {
-		return nil, fmt.Errorf("device with the given address was not found")
+		return Device{}, fmt.Errorf("device with the given address was not found")
 	}
 
 	bleDevice := (*bluetooth.BluetoothLEDevice)(res)
@@ -204,37 +204,37 @@ func (a *Adapter) Connect(address Address, params ConnectionParams) (*Device, er
 	// To initiate a connection, we need to set GattSession.MaintainConnection to true.
 	dID, err := bleDevice.GetBluetoothDeviceId()
 	if err != nil {
-		return nil, err
+		return Device{}, err
 	}
 
 	// Windows does not support explicitly connecting to a device.
 	// Instead it has the concept of a GATT session that is owned
 	// by the calling program.
 	gattSessionOp, err := genericattributeprofile.FromDeviceIdAsync(dID) // IAsyncOperation<GattSession>
 	if err != nil {
-		return nil, err
+		return Device{}, err
 	}
 
 	if err := awaitAsyncOperation(gattSessionOp, genericattributeprofile.SignatureGattSession); err != nil {
-		return nil, fmt.Errorf("error getting gatt session: %w", err)
+		return Device{}, fmt.Errorf("error getting gatt session: %w", err)
 	}
 
 	gattRes, err := gattSessionOp.GetResults()
 	if err != nil {
-		return nil, err
+		return Device{}, err
 	}
 	newSession := (*genericattributeprofile.GattSession)(gattRes)
 	// This keeps the device connected until we set maintain_connection = False.
 	if err := newSession.SetMaintainConnection(true); err != nil {
-		return nil, err
+		return Device{}, err
 	}
 
-	return &Device{bleDevice, newSession}, nil
+	return Device{bleDevice, newSession}, nil
 }
 
 // Disconnect from the BLE device. This method is non-blocking and does not
 // wait until the connection is fully gone.
-func (d *Device) Disconnect() error {
+func (d Device) Disconnect() error {
 	defer d.device.Release()
 	defer d.session.Release()
 

gattc_darwin.go

@@ -14,7 +14,7 @@ import (
 //
 // Passing a nil slice of UUIDs will return a complete list of
 // services.
-func (d *Device) DiscoverServices(uuids []UUID) ([]DeviceService, error) {
+func (d Device) DiscoverServices(uuids []UUID) ([]DeviceService, error) {
 	d.prph.DiscoverServices([]cbgo.UUID{})
 
 	// clear cache of services
@@ -69,7 +69,7 @@ type DeviceService struct {
 type deviceService struct {
 	uuidWrapper
 
-	device *Device
+	device Device
 
 	service         cbgo.Service
 	characteristics []DeviceCharacteristic

gattc_linux.go

@@ -43,7 +43,7 @@ func (s *DeviceService) UUID() UUID {
 //
 // On Linux with BlueZ, this just waits for the ServicesResolved signal (if
 // services haven't been resolved yet) and uses this list of cached services.
-func (d *Device) DiscoverServices(uuids []UUID) ([]DeviceService, error) {
+func (d Device) DiscoverServices(uuids []UUID) ([]DeviceService, error) {
 	start := time.Now()
 
 	for {

gattc_sd.go

@@ -59,7 +59,7 @@ func (s *DeviceService) UUID() UUID {
 //
 // On the Nordic SoftDevice, only one service discovery procedure may be done at
 // a time.
-func (d *Device) DiscoverServices(uuids []UUID) ([]DeviceService, error) {
+func (d Device) DiscoverServices(uuids []UUID) ([]DeviceService, error) {
 	if discoveringService.state.Get() != 0 {
 		// Not concurrency safe, but should catch most concurrency misuses.
 		return nil, errAlreadyDiscovering

gattc_windows.go

@@ -30,7 +30,7 @@ var (
 //
 // Passing a nil slice of UUIDs will return a complete list of
 // services.
-func (d *Device) DiscoverServices(filterUUIDs []UUID) ([]DeviceService, error) {
+func (d Device) DiscoverServices(filterUUIDs []UUID) ([]DeviceService, error) {
 	// IAsyncOperation<GattDeviceServicesResult>
 	getServicesOperation, err := d.device.GetGattServicesWithCacheModeAsync(bluetooth.BluetoothCacheModeUncached)
 	if err != nil {
@@ -133,7 +133,7 @@ type DeviceService struct {
 	uuidWrapper
 
 	service *genericattributeprofile.GattDeviceService
-	device  *Device
+	device  Device
 }
 
 // UUID returns the UUID for this DeviceService.