package infinitime import ( "bytes" "encoding/binary" "errors" "fmt" "time" bt "github.com/muka/go-bluetooth/api" "github.com/muka/go-bluetooth/bluez/profile/adapter" "github.com/muka/go-bluetooth/bluez/profile/device" "github.com/muka/go-bluetooth/bluez/profile/gatt" ) const BTName = "InfiniTime" const ( NewAlertChar = "00002a46-0000-1000-8000-00805f9b34fb" FirmwareVerChar = "00002a26-0000-1000-8000-00805f9b34fb" CurrentTimeChar = "00002a2b-0000-1000-8000-00805f9b34fb" BatteryLvlChar = "00002a19-0000-1000-8000-00805f9b34fb" HeartRateChar = "00002a37-0000-1000-8000-00805f9b34fb" ) type Device struct { opts *Options device *device.Device1 newAlertChar *gatt.GattCharacteristic1 fwVersionChar *gatt.GattCharacteristic1 currentTimeChar *gatt.GattCharacteristic1 battLevelChar *gatt.GattCharacteristic1 heartRateChar *gatt.GattCharacteristic1 onReconnect func() Music MusicCtrl DFU DFU } var ErrNoDevices = errors.New("no InfiniTime devices found") var ErrNotFound = errors.New("could not find any advertising InfiniTime devices") type Options struct { AttemptReconnect bool } var DefaultOptions = &Options{ AttemptReconnect: true, } // Connect will attempt to connect to a // paired InfiniTime device. If none are paired, // it will attempt to discover and pair one. // // It will also attempt to reconnect to the device // if it disconnects. func Connect(opts *Options) (*Device, error) { if opts == nil { opts = DefaultOptions } // Attempt to connect to paired device by name dev, err := connectByName() // If such device does not exist if errors.Is(err, ErrNoDevices) { // Attempt to pair device dev, err = pair() } if err != nil { return nil, err } dev.opts = opts dev.onReconnect = func() {} // Watch device properties devEvtCh, err := dev.device.WatchProperties() if err != nil { return nil, err } // If AttemptReconnect enabled if dev.opts.AttemptReconnect { go func() { disconnEvtNum := 0 // For every event for evt := range devEvtCh { // If device disconnected if evt.Name == "Connected" && evt.Value == false { // Increment disconnect event number disconnEvtNum++ // If more than one disconnect event if disconnEvtNum > 1 { // Decrement disconnect event number disconnEvtNum-- // Skip loop continue } // Set connected to false dev.device.Properties.Connected = false // While not connected for !dev.device.Properties.Connected { // Attempt to connect via bluetooth address reConnDev, err := ConnectByAddress(dev.device.Properties.Address) if err != nil { // Decrement disconnect event number disconnEvtNum-- // Skip rest of loop continue } // Store onReconn callback onReconn := dev.onReconnect // Set device to new device *dev = *reConnDev // Run on reconnect callback onReconn() // Assign callback to new device dev.onReconnect = onReconn } // Decrement disconnect event number disconnEvtNum-- } } }() } return dev, nil } // OnReconnect sets the callback that runs on reconnect func (i *Device) OnReconnect(f func()) { i.onReconnect = f } // Connect connects to a paired InfiniTime device func connectByName() (*Device, error) { // Create new device out := &Device{} // Get devices from default adapter devs, err := defaultAdapter.GetDevices() if err != nil { return nil, err } // For every device for _, dev := range devs { // If device name is InfiniTime if dev.Properties.Name == BTName { // Set outout device to discovered device out.device = dev break } } if out.device == nil { return nil, ErrNoDevices } // Connect to device err = out.device.Connect() if err != nil { return nil, err } // Resolve characteristics err = out.resolveChars() if err != nil { return nil, err } return out, nil } // Pair attempts to discover and pair an InfiniTime device func pair() (*Device, error) { // Create new device out := &Device{} // Start bluetooth discovery // Ignore the cancel function as it blocks forever discovery, _, err := bt.Discover(defaultAdapter, &adapter.DiscoveryFilter{Transport: "le"}) if err != nil { return nil, err } // For every discovery event for event := range discovery { // If device removed, skip event if event.Type == adapter.DeviceRemoved { continue } // Create new device with discovered path dev, err := device.NewDevice1(event.Path) if err != nil { return nil, err } // If device name is InfiniTime if dev.Properties.Name == BTName { // Set output device out.device = dev break } } if out.device == nil { return nil, ErrNotFound } // Pair device out.device.Pair() // Set connected to true out.device.Properties.Connected = true // Resolve characteristics err = out.resolveChars() if err != nil { return nil, err } return out, nil } // ConnectByAddress tries to connect to an InifiniTime at // the specified InfiniTime address func ConnectByAddress(addr string) (*Device, error) { var err error // Create new device out := &Device{} // Get device from bluetooth address out.device, err = defaultAdapter.GetDeviceByAddress(addr) if err != nil { return nil, err } // Connect to device err = out.device.Connect() if err != nil { return nil, err } // Resolve characteristics err = out.resolveChars() if err != nil { return nil, err } return out, nil } // resolveChars attempts to set all required // characteristics in an InfiniTime struct func (i *Device) resolveChars() error { // Get device characteristics chars, err := i.device.GetCharacteristics() if err != nil { return err } // While no characteristics found for len(chars) == 0 { // Sleep one second time.Sleep(time.Second) // Attempt to retry getting characteristics chars, err = i.device.GetCharacteristics() if err != nil { return err } } // For every discovered characteristics for _, char := range chars { // Set correct characteristics switch char.Properties.UUID { case NewAlertChar: i.newAlertChar = char case FirmwareVerChar: i.fwVersionChar = char case CurrentTimeChar: i.currentTimeChar = char case BatteryLvlChar: i.battLevelChar = char case HeartRateChar: i.heartRateChar = char case MusicEventChar: i.Music.eventChar = char case MusicStatusChar: i.Music.statusChar = char case MusicArtistChar: i.Music.artistChar = char case MusicTrackChar: i.Music.trackChar = char case MusicAlbumChar: i.Music.albumChar = char case DFUCtrlPointChar: i.DFU.ctrlPointChar = char case DFUPacketChar: i.DFU.packetChar = char } } return nil } // Address returns the InfiniTime's bluetooth address func (i *Device) Address() string { return i.device.Properties.Address } // Version returns InfiniTime's reported firmware version string func (i *Device) Version() (string, error) { if !i.device.Properties.Connected { return "", nil } ver, err := i.fwVersionChar.ReadValue(nil) return string(ver), err } // BatteryLevel gets the watch's battery level via the Battery Service func (i *Device) BatteryLevel() (uint8, error) { if !i.device.Properties.Connected { return 0, nil } battLevel, err := i.battLevelChar.ReadValue(nil) if err != nil { return 0, err } return uint8(battLevel[0]), nil } func (i *Device) HeartRate() (uint8, error) { if !i.device.Properties.Connected { return 0, nil } heartRate, err := i.heartRateChar.ReadValue(nil) if err != nil { return 0, err } return uint8(heartRate[1]), nil } func (i *Device) WatchHeartRate() (<-chan uint8, error) { if !i.device.Properties.Connected { return make(<-chan uint8), nil } // Start notifications on heart rate characteristic err := i.heartRateChar.StartNotify() if err != nil { return nil, err } // Watch characteristics of heart rate characteristic ch, err := i.heartRateChar.WatchProperties() if err != nil { return nil, err } out := make(chan uint8, 2) currentHeartRate, err := i.HeartRate() if err != nil { return nil, err } out <- currentHeartRate go func() { // For every event for event := range ch { // If value changed if event.Name == "Value" { // Send heart rate to channel out <- uint8(event.Value.([]byte)[1]) } } }() return out, nil } func (i *Device) WatchBatteryLevel() (<-chan uint8, error) { if !i.device.Properties.Connected { return make(<-chan uint8), nil } // Start notifications on heart rate characteristic err := i.battLevelChar.StartNotify() if err != nil { return nil, err } // Watch characteristics of heart rate characteristic ch, err := i.battLevelChar.WatchProperties() if err != nil { return nil, err } out := make(chan uint8, 2) currentBattLevel, err := i.BatteryLevel() if err != nil { return nil, err } out <- currentBattLevel go func() { // For every event for event := range ch { // If value changed if event.Name == "Value" { // Send heart rate to channel out <- uint8(event.Value.([]byte)[0]) } } }() return out, nil } // SetTime sets the watch's time using the Current Time Service func (i *Device) SetTime(t time.Time) error { if !i.device.Properties.Connected { return nil } buf := &bytes.Buffer{} binary.Write(buf, binary.LittleEndian, uint16(t.Year())) binary.Write(buf, binary.LittleEndian, uint8(t.Month())) binary.Write(buf, binary.LittleEndian, uint8(t.Day())) binary.Write(buf, binary.LittleEndian, uint8(t.Hour())) binary.Write(buf, binary.LittleEndian, uint8(t.Minute())) binary.Write(buf, binary.LittleEndian, uint8(t.Second())) binary.Write(buf, binary.LittleEndian, uint8(t.Weekday())) binary.Write(buf, binary.LittleEndian, uint8((t.Nanosecond()/1000)/1e6*256)) binary.Write(buf, binary.LittleEndian, uint8(0b0001)) return i.currentTimeChar.WriteValue(buf.Bytes(), nil) } // Notify sends a notification to InfiniTime via // the Alert Notification Service (ANS) func (i *Device) Notify(title, body string) error { if !i.device.Properties.Connected { return nil } return i.newAlertChar.WriteValue( []byte(fmt.Sprintf("00\x00%s\x00%s", title, body)), nil, ) }