infinitime/infinitime.go

392 lines
9.4 KiB
Go
Raw Normal View History

2021-08-20 00:41:09 +00:00
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
2021-08-22 03:24:56 +00:00
PairTimeout time.Duration
2021-08-20 00:41:09 +00:00
}
var DefaultOptions = &Options{
AttemptReconnect: true,
2021-08-22 03:24:56 +00:00
PairTimeout: time.Minute,
2021-08-20 00:41:09 +00:00
}
// 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(opts.PairTimeout)
2021-08-20 00:41:09 +00:00
}
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
2021-08-22 03:25:09 +00:00
err = out.device.Connect()
if err != nil {
return nil, err
}
2021-08-20 00:41:09 +00:00
// Resolve characteristics
err = out.resolveChars()
if err != nil {
return nil, err
}
return out, nil
}
// Pair attempts to discover and pair an InfiniTime device
2021-08-22 03:24:56 +00:00
func pair(timeout time.Duration) (*Device, error) {
2021-08-20 00:41:09 +00:00
// Create new device
out := &Device{}
// Start bluetooth discovery
discovery, cancelDiscover, err := bt.Discover(defaultAdapter, &adapter.DiscoveryFilter{Transport: "le"})
if err != nil {
return nil, err
}
// Cancel discovery at end of function
defer cancelDiscover()
discoveryLoop:
for {
select {
case event := <-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 out of discoveryLoop
break discoveryLoop
}
2021-08-22 03:24:56 +00:00
case <-time.After(timeout):
2021-08-20 00:41:09 +00:00
break discoveryLoop
}
}
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)
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
}
// 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,
)
}