Merge remote-tracking branch 'benma/bt'

Author: benma

backend/backend.go

@@ -39,6 +39,7 @@ import (
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/config"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bluetooth"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/device"
 	deviceevent "github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/device/event"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/usb"
@@ -176,6 +177,9 @@ type Environment interface {
 	// OnAuthSettingChanged is called when the authentication (screen lock) setting is changed.
 	// This is also called when the app launches with the current setting.
 	OnAuthSettingChanged(enabled bool)
+	// BluetoothConnect tries to connect to the peripheral by the given identifier.
+	// Use `backend.bluetooth.State()` to track failure.
+	BluetoothConnect(identifier string)
 }
 
 // Backend ties everything together and is the main starting point to use the BitBox wallet library.
@@ -194,6 +198,7 @@ type Backend struct {
 	devices map[string]device.Interface
 
 	usbManager *usb.Manager
+	bluetooth  *bluetooth.Bluetooth
 
 	accountsAndKeystoreLock locker.Locker
 	accounts                AccountsList
@@ -265,7 +270,6 @@ func NewBackend(arguments *arguments.Arguments, environment Environment) (*Backe
 		coins:    map[coinpkg.Code]coinpkg.Coin{},
 		accounts: []accounts.Interface{},
 		aopp:     AOPP{State: aoppStateInactive},
-
 		makeBtcAccount: func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, log *logrus.Entry) accounts.Interface {
 			return btc.NewAccount(config, coin, gapLimits, log, hclient)
 		},
@@ -297,6 +301,9 @@ func NewBackend(arguments *arguments.Arguments, environment Environment) (*Backe
 	backend.banners = banners.NewBanners()
 	backend.banners.Observe(backend.Notify)
 
+	backend.bluetooth = bluetooth.New(log)
+	backend.bluetooth.Observe(backend.Notify)
+
 	return backend, nil
 }
 
@@ -1052,3 +1059,8 @@ func (backend *Backend) ExportLogs() error {
 	}
 	return nil
 }
+
+// Bluetooth returns the backend's bluetooth instance.
+func (backend *Backend) Bluetooth() *bluetooth.Bluetooth {
+	return backend.bluetooth
+}

backend/backend_test.go

@@ -244,6 +244,8 @@ func (e environment) Auth() {}
 
 func (e environment) OnAuthSettingChanged(bool) {}
 
+func (e environment) BluetoothConnect(string) {}
+
 type mockTransactionsSource struct {
 }
 

backend/bridgecommon/bridgecommon.go

@@ -19,6 +19,7 @@ package bridgecommon
 import (
 	"bytes"
 	"encoding/hex"
+	"encoding/json"
 	"net/http"
 	"runtime"
 	"runtime/debug"
@@ -28,6 +29,7 @@ import (
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/arguments"
 	btctypes "github.com/BitBoxSwiss/bitbox-wallet-app/backend/coins/btc/types"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bluetooth"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/usb"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/handlers"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/config"
@@ -192,6 +194,7 @@ type BackendEnvironment struct {
 	DetectDarkThemeFunc      func() bool
 	AuthFunc                 func()
 	OnAuthSettingChangedFunc func(bool)
+	BluetoothConnectFunc     func(string)
 }
 
 // NotifyUser implements backend.Environment.
@@ -270,6 +273,13 @@ func (env *BackendEnvironment) OnAuthSettingChanged(enabled bool) {
 	}
 }
 
+// BluetoothConnect implements backend.Environment.
+func (env *BackendEnvironment) BluetoothConnect(identifier string) {
+	if env.BluetoothConnectFunc != nil {
+		env.BluetoothConnectFunc(identifier)
+	}
+}
+
 // Serve serves the BitBox API for use in a native client.
 func Serve(
 	testnet bool,
@@ -369,3 +379,19 @@ func UsbUpdate() {
 	}
 	globalBackend.UsbUpdate()
 }
+
+// BluetoothSetState wraps backend.Bluetooth().SetState.
+// The json byte are parsed according to `bluetooth.State`.
+func BluetoothSetState(jsonState string) error {
+	mu.RLock()
+	defer mu.RUnlock()
+	if globalBackend == nil {
+		return nil
+	}
+	var state bluetooth.State
+	if err := json.Unmarshal([]byte(jsonState), &state); err != nil {
+		return err
+	}
+	globalBackend.Bluetooth().SetState(&state)
+	return nil
+}

backend/bridgecommon/bridgecommon_test.go

@@ -73,6 +73,8 @@ func (e environment) Auth() {}
 
 func (e environment) OnAuthSettingChanged(bool) {}
 
+func (e environment) BluetoothConnect(string) {}
+
 // TestServeShutdownServe checks that you can call Serve twice in a row.
 func TestServeShutdownServe(t *testing.T) {
 	bridgecommon.Serve(

backend/devices/bluetooth/bluetooth.go

@@ -0,0 +1,76 @@
+// Copyright 2025 Shift Crypto AG
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bluetooth
+
+import (
+	"github.com/BitBoxSwiss/bitbox-wallet-app/util/locker"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/util/observable"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/util/observable/action"
+	"github.com/sirupsen/logrus"
+)
+
+// Peripheral is a bluetooth peripheral.
+type Peripheral struct {
+	Identifier      string  `json:"identifier"`
+	Name            string  `json:"name"`
+	ConnectionError *string `json:"connectionError,omitempty"`
+}
+
+// State contains everything needed to render bluetooth peripherals and other data in the frontend.
+type State struct {
+	// BluetoothAvailable is false if bluetooth is powered off or otherwise unavailable.
+	BluetoothAvailable bool          `json:"bluetoothAvailable"`
+	Peripherals        []*Peripheral `json:"peripherals"`
+	Connecting         bool          `json:"connecting"`
+}
+
+// Bluetooth manages a list of peripherals.
+type Bluetooth struct {
+	observable.Implementation
+
+	state     *State
+	stateLock locker.Locker
+
+	log *logrus.Entry
+}
+
+// New creates a new instance of Bluetooth.
+func New(log *logrus.Entry) *Bluetooth {
+	b := &Bluetooth{
+		state: &State{
+			Peripherals: []*Peripheral{},
+		},
+		log: log,
+	}
+	return b
+}
+
+// SetState sets the current list of discovered peripherals and other state data.
+func (b *Bluetooth) SetState(state *State) {
+	defer b.stateLock.Lock()()
+	b.log.WithField("state", state).Info("bluetooth setstate")
+	b.state = state
+	b.Notify(observable.Event{
+		Subject: "bluetooth/state",
+		Action:  action.Replace,
+		Object:  state,
+	})
+}
+
+// State returns the current list of discovered peripherals and other bluetooth state data.
+func (b *Bluetooth) State() *State {
+	defer b.stateLock.RLock()()
+	return b.state
+}

backend/handlers/handlers.go

@@ -45,6 +45,7 @@ import (
 	bitbox02Handlers "github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02/handlers"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02bootloader"
 	bitbox02bootloaderHandlers "github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bitbox02bootloader/handlers"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/bluetooth"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/devices/device"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/exchanges"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/keystore"
@@ -117,6 +118,7 @@ type Backend interface {
 	CancelConnectKeystore()
 	SetWatchonly(rootFingerprint []byte, watchonly bool) error
 	LookupEthAccountCode(address string) (accountsTypes.Code, string, error)
+	Bluetooth() *bluetooth.Bluetooth
 }
 
 // Handlers provides a web api to the backend.
@@ -262,6 +264,9 @@ func NewHandlers(
 	getAPIRouterNoError(apiRouter)("/notes/export", handlers.postExportNotes).Methods("POST")
 	getAPIRouterNoError(apiRouter)("/notes/import", handlers.postImportNotes).Methods("POST")
 
+	getAPIRouterNoError(apiRouter)("/bluetooth/state", handlers.getBluetoothState).Methods("GET")
+	getAPIRouterNoError(apiRouter)("/bluetooth/connect", handlers.postBluetoothConnect).Methods("POST")
+
 	devicesRouter := getAPIRouterNoError(apiRouter.PathPrefix("/devices").Subrouter())
 	devicesRouter("/registered", handlers.getDevicesRegistered).Methods("GET")
 
@@ -1616,3 +1621,18 @@ func (handlers *Handlers) postImportNotes(r *http.Request) interface{} {
 	}
 	return result{Success: true, Data: data}
 }
+
+func (handlers *Handlers) getBluetoothState(r *http.Request) interface{} {
+	return handlers.backend.Bluetooth().State()
+}
+
+func (handlers *Handlers) postBluetoothConnect(r *http.Request) interface{} {
+	var identifier string
+	if err := json.NewDecoder(r.Body).Decode(&identifier); err != nil {
+		// We assume this will never fail to simplify handling in the frontend.
+		return nil
+	}
+
+	handlers.backend.Environment().BluetoothConnect(identifier)
+	return nil
+}

backend/handlers/handlers_test.go

@@ -60,6 +60,7 @@ func (e *backendEnv) SetDarkTheme(bool)             {}
 func (e *backendEnv) DetectDarkTheme() bool         { return false }
 func (e *backendEnv) Auth()                         {}
 func (e *backendEnv) OnAuthSettingChanged(bool)     {}
+func (e *backendEnv) BluetoothConnect(string)       {}
 
 func TestGetNativeLocale(t *testing.T) {
 	const ptLocale = "pt"

backend/mobileserver/mobileserver.go

@@ -100,6 +100,7 @@ type GoEnvironmentInterface interface {
 	DetectDarkTheme() bool
 	Auth()
 	OnAuthSettingChanged(bool)
+	BluetoothConnect(string)
 }
 
 // readWriteCloser implements io.ReadWriteCloser, translating from GoReadWriteCloserInterface. All methods
@@ -212,6 +213,7 @@ func Serve(dataDir string, testnet bool, environment GoEnvironmentInterface, goA
 			DetectDarkThemeFunc:      environment.DetectDarkTheme,
 			AuthFunc:                 environment.Auth,
 			OnAuthSettingChangedFunc: environment.OnAuthSettingChanged,
+			BluetoothConnectFunc:     environment.BluetoothConnect,
 		},
 	)
 }
@@ -242,3 +244,8 @@ func AuthResult(ok bool) {
 func ManualReconnect() {
 	bridgecommon.ManualReconnect()
 }
+
+// BluetoothSetState wraps bridgecommon.BluetoothSetState.
+func BluetoothSetState(jsonState string) error {
+	return bridgecommon.BluetoothSetState(jsonState)
+}

cmd/servewallet/main.go

@@ -96,6 +96,10 @@ func (webdevEnvironment) Auth() {
 func (webdevEnvironment) OnAuthSettingChanged(enabled bool) {
 }
 
+// BluetoothConnect implements backend.Environment.
+func (webdevEnvironment) BluetoothConnect(identifier string) {
+}
+
 // NativeLocale naively implements backend.Environment.
 // This version is unlikely to work on Windows.
 func (webdevEnvironment) NativeLocale() string {

frontends/android/BitBoxApp/app/src/main/java/ch/shiftcrypto/bitboxapp/GoViewModel.java

@@ -136,6 +136,9 @@ public void onAuthSettingChanged(boolean enabled) {
             authSetting.postValue(enabled);
         }
 
+        public void bluetoothConnect(String identifier) {
+        }
+
         public boolean usingMobileData() {
             // Adapted from https://stackoverflow.com/a/53243938
 

frontends/ios/BitBoxApp/BitBoxApp/BitBoxAppApp.swift

@@ -40,35 +40,34 @@ protocol SetMessageHandlersProtocol {
 
 class GoEnvironment: NSObject, MobileserverGoEnvironmentInterfaceProtocol, UIDocumentInteractionControllerDelegate {
     private let bluetoothManager: BluetoothManager
-    
+
     init(bluetoothManager: BluetoothManager) {
         self.bluetoothManager = bluetoothManager
     }
-    
+
     func getSaveFilename(_ fileName: String?) -> String {
         let tempDirectory = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
         // fileName cannot be nil this is called by Go and Go strings cannot be nil/null.
         let fileURL = tempDirectory.appendingPathComponent(fileName!)
         return fileURL.path
     }
-    
+
     func auth() {
         authenticateUser { success in
             // TODO: enabling auth but entering wrong passcode does not remove auth screen
             MobileserverAuthResult(success)
         }
     }
-    
+
     func detectDarkTheme() -> Bool {
         return UIScreen.main.traitCollection.userInterfaceStyle == .dark
     }
-    
+
     func deviceInfo() -> MobileserverGoDeviceInfoInterfaceProtocol? {
         if !bluetoothManager.isConnected() {
             return nil
         }
-        print("Bluetooth product string: \(bluetoothManager.productStr())")
-
+       
         let productStr = bluetoothManager.productStr();
         if productStr == "" || productStr == "no connection" {
             // Not ready or explicitly not connected (waiting for the device to enter
@@ -89,6 +88,16 @@ class GoEnvironment: NSObject, MobileserverGoEnvironmentInterfaceProtocol, UIDoc
         // TODO: hide app window contents in app switcher, maybe always not just when auth is on.
     }
 
+    func bluetoothConnect(_ identifier: String?) {
+        guard let identifier = identifier else {
+            return
+        }
+        guard let uuid = UUID(uuidString: identifier) else {
+            return
+        }
+        bluetoothManager.connect(to: uuid)
+    }
+
     func setDarkTheme(_ p0: Bool) {
     }
 
@@ -159,7 +168,7 @@ class GoAPI: NSObject, MobileserverGoAPIInterfaceProtocol, SetMessageHandlersPro
 @main
 struct BitBoxAppApp: App {
     @StateObject private var bluetoothManager = BluetoothManager()
-    
+
     var body: some Scene {
         WindowGroup {
             GridLayout(alignment: .leading) {