infinitime/infinitime.go

697 lines
17 KiB
Go

package infinitime
import (
"bytes"
"encoding/binary"
"errors"
"strings"
"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"
"go.arsenm.dev/infinitime/blefs"
)
const BTName = "InfiniTime"
const (
NewAlertChar = "00002a46-0000-1000-8000-00805f9b34fb"
NotifEventChar = "00020001-78fc-48fe-8e23-433b3a1942d0"
StepCountChar = "00030001-78fc-48fe-8e23-433b3a1942d0"
MotionValChar = "00030002-78fc-48fe-8e23-433b3a1942d0"
FirmwareVerChar = "00002a26-0000-1000-8000-00805f9b34fb"
CurrentTimeChar = "00002a2b-0000-1000-8000-00805f9b34fb"
BatteryLvlChar = "00002a19-0000-1000-8000-00805f9b34fb"
HeartRateChar = "00002a37-0000-1000-8000-00805f9b34fb"
FSTransferChar = "adaf0200-4669-6c65-5472-616e73666572"
FSVersionChar = "adaf0100-4669-6c65-5472-616e73666572"
)
type Device struct {
opts *Options
device *device.Device1
newAlertChar *gatt.GattCharacteristic1
notifEventChar *gatt.GattCharacteristic1
stepCountChar *gatt.GattCharacteristic1
motionValChar *gatt.GattCharacteristic1
fwVersionChar *gatt.GattCharacteristic1
currentTimeChar *gatt.GattCharacteristic1
battLevelChar *gatt.GattCharacteristic1
heartRateChar *gatt.GattCharacteristic1
fsVersionChar *gatt.GattCharacteristic1
fsTransferChar *gatt.GattCharacteristic1
notifEventCh chan uint8
notifEventDone bool
onReconnect func()
Music MusicCtrl
DFU DFU
}
var (
ErrNoDevices = errors.New("no InfiniTime devices found")
ErrNotFound = errors.New("could not find any advertising InfiniTime devices")
ErrNotConnected = errors.New("not connected")
ErrCharNotAvail = errors.New("required characteristic is not available")
)
type Options struct {
AttemptReconnect bool
WhitelistEnabled bool
Whitelist []string
}
var DefaultOptions = &Options{
AttemptReconnect: true,
WhitelistEnabled: false,
}
// 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(opts)
// If such device does not exist
if errors.Is(err, ErrNoDevices) {
// Attempt to pair device
dev, err = pair(opts)
}
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(opts *Options) (*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 {
if opts.WhitelistEnabled && !contains(opts.Whitelist, dev.Properties.Address) {
continue
}
// 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
}
out.device.Properties.Connected = true
// Resolve characteristics
err = out.resolveChars()
if err != nil {
return nil, err
}
return out, nil
}
func contains(ss []string, s string) bool {
for _, str := range ss {
if strings.EqualFold(str, s) {
return true
}
}
return false
}
// Pair attempts to discover and pair an InfiniTime device
func pair(opts *Options) (*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 {
if opts.WhitelistEnabled && !contains(opts.Whitelist, dev.Properties.Address) {
continue
}
// Set output device
out.device = dev
break
}
}
if out.device == nil {
return nil, ErrNotFound
}
// Pair device
out.device.Pair()
out.device.Properties.Connected = true
// 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
}
out.device.Properties.Connected = true
// 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 NotifEventChar:
i.notifEventChar = char
case StepCountChar:
i.stepCountChar = char
case MotionValChar:
i.motionValChar = 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
case FSTransferChar:
i.fsTransferChar = char
case FSVersionChar:
i.fsVersionChar = 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 err := i.checkStatus(i.fwVersionChar); err != nil {
return "", err
}
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 err := i.checkStatus(i.battLevelChar); err != nil {
return 0, err
}
battLevel, err := i.battLevelChar.ReadValue(nil)
if err != nil {
return 0, err
}
return uint8(battLevel[0]), nil
}
func (i *Device) StepCount() (uint32, error) {
if err := i.checkStatus(i.stepCountChar); err != nil {
return 0, err
}
stepCountData, err := i.stepCountChar.ReadValue(nil)
if err != nil {
return 0, err
}
return binary.LittleEndian.Uint32(stepCountData), nil
}
type MotionValues struct {
X int16
Y int16
Z int16
}
func (i *Device) Motion() (MotionValues, error) {
out := MotionValues{}
if err := i.checkStatus(i.motionValChar); err != nil {
return out, err
}
motionVals, err := i.motionValChar.ReadValue(nil)
if err != nil {
return out, nil
}
motionValReader := bytes.NewReader(motionVals)
err = binary.Read(motionValReader, binary.LittleEndian, &out)
if err != nil {
return out, err
}
return out, nil
}
func (i *Device) HeartRate() (uint8, error) {
if err := i.checkStatus(i.heartRateChar); err != nil {
return 0, err
}
heartRate, err := i.heartRateChar.ReadValue(nil)
if err != nil {
return 0, err
}
return uint8(heartRate[1]), nil
}
func (i *Device) WatchHeartRate() (<-chan uint8, func(), error) {
if err := i.checkStatus(i.heartRateChar); err != nil {
return nil, nil, err
}
// Start notifications on heart rate characteristic
err := i.heartRateChar.StartNotify()
if err != nil {
return nil, nil, err
}
// Watch characteristics of heart rate characteristic
ch, err := i.heartRateChar.WatchProperties()
if err != nil {
return nil, nil, err
}
out := make(chan uint8, 2)
currentHeartRate, err := i.HeartRate()
if err != nil {
return nil, nil, err
}
out <- currentHeartRate
cancel, done := cancelFunc()
go func() {
// For every event
for event := range ch {
select {
case <-done:
close(out)
close(done)
i.heartRateChar.StopNotify()
return
default:
// If value changed
if event.Name == "Value" {
// Send heart rate to channel
out <- uint8(event.Value.([]byte)[1])
}
}
}
}()
return out, cancel, nil
}
func (i *Device) WatchBatteryLevel() (<-chan uint8, func(), error) {
if err := i.checkStatus(i.battLevelChar); err != nil {
return nil, nil, err
}
// Start notifications on heart rate characteristic
err := i.battLevelChar.StartNotify()
if err != nil {
return nil, nil, err
}
// Watch characteristics of heart rate characteristic
ch, err := i.battLevelChar.WatchProperties()
if err != nil {
return nil, nil, err
}
out := make(chan uint8, 2)
currentBattLevel, err := i.BatteryLevel()
if err != nil {
return nil, nil, err
}
out <- currentBattLevel
cancel, done := cancelFunc()
go func() {
// For every event
for event := range ch {
select {
case <-done:
close(out)
close(done)
i.battLevelChar.StopNotify()
return
default:
// If value changed
if event.Name == "Value" {
// Send heart rate to channel
out <- uint8(event.Value.([]byte)[0])
}
}
}
}()
return out, cancel, nil
}
func (i *Device) WatchStepCount() (<-chan uint32, func(), error) {
if err := i.checkStatus(i.stepCountChar); err != nil {
return nil, nil, err
}
// Start notifications on step count characteristic
err := i.stepCountChar.StartNotify()
if err != nil {
return nil, nil, err
}
// Watch properties of step count characteristic
ch, err := i.stepCountChar.WatchProperties()
if err != nil {
return nil, nil, err
}
out := make(chan uint32, 2)
currentStepCount, err := i.StepCount()
if err != nil {
return nil, nil, err
}
out <- currentStepCount
cancel, done := cancelFunc()
go func() {
// For every event
for event := range ch {
select {
case <-done:
close(out)
close(done)
i.stepCountChar.StopNotify()
return
default:
// If value changed
if event.Name == "Value" {
// Send step count to channel
out <- binary.LittleEndian.Uint32(event.Value.([]byte))
}
}
}
}()
return out, cancel, nil
}
func (i *Device) WatchMotion() (<-chan MotionValues, func(), error) {
if err := i.checkStatus(i.motionValChar); err != nil {
return nil, nil, err
}
// Start notifications on motion characteristic
err := i.motionValChar.StartNotify()
if err != nil {
return nil, nil, err
}
// Watch properties of motion characteristic
ch, err := i.motionValChar.WatchProperties()
if err != nil {
return nil, nil, err
}
out := make(chan MotionValues, 2)
motionVals, err := i.Motion()
if err != nil {
return nil, nil, err
}
out <- motionVals
cancel, done := cancelFunc()
go func() {
// For every event
for event := range ch {
select {
case <-done:
close(out)
close(done)
i.motionValChar.StopNotify()
return
default:
// If value changed
if event.Name == "Value" {
// Read binary into MotionValues struct
binary.Read(bytes.NewReader(event.Value.([]byte)), binary.LittleEndian, &motionVals)
// Send step count to channel
out <- motionVals
}
}
}
}()
return out, cancel, nil
}
func cancelFunc() (func(), chan struct{}) {
done := make(chan struct{}, 1)
return func() {
done <- struct{}{}
}, done
}
// SetTime sets the watch's time using the Current Time Service
func (i *Device) SetTime(t time.Time) error {
if err := i.checkStatus(i.currentTimeChar); err != nil {
return err
}
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 err := i.checkStatus(i.newAlertChar); err != nil {
return err
}
return i.newAlertChar.WriteValue(
append([]byte{0x00, 0x01, 0x00}, []byte(title+"\x00"+body)...),
nil,
)
}
// These constants represent the possible call statuses selected by the user
const (
CallStatusDeclined uint8 = iota
CallStatusAccepted
CallStatusMuted
)
// NotifyCall sends a call notification to the PineTime and returns a channel.
// This channel will contain the user's response to the call notification.
func (i *Device) NotifyCall(from string) (<-chan uint8, error) {
if err := i.checkStatus(i.newAlertChar); err != nil {
return nil, err
}
// Write call notification to new alert characteristic
err := i.newAlertChar.WriteValue(
append([]byte{0x03, 0x01, 0x00}, []byte(from)...),
nil,
)
if err != nil {
return nil, err
}
if !i.notifEventDone {
err = i.initNotifEvent()
if err != nil {
return nil, err
}
i.notifEventDone = true
}
return i.notifEventCh, nil
}
// initNotifEvent initializes the notification event channel
func (i *Device) initNotifEvent() error {
// Start notifications on notification event characteristic
err := i.notifEventChar.StartNotify()
if err != nil {
return err
}
// Watch properties of notification event characteristic
ch, err := i.notifEventChar.WatchProperties()
if err != nil {
return err
}
// Create new output channel for status
i.notifEventCh = make(chan uint8, 1)
go func() {
// For every event
for event := range ch {
// If value changed
if event.Name == "Value" {
// Send status to channel
i.notifEventCh <- uint8(event.Value.([]byte)[0])
}
}
}()
return nil
}
// FS creates and returns a new filesystem from the device
func (i *Device) FS() (*blefs.FS, error) {
if err := i.checkStatus(i.fsTransferChar); err != nil {
return nil, err
}
return blefs.New(i.fsTransferChar)
}
func (i *Device) checkStatus(char *gatt.GattCharacteristic1) error {
if !i.device.Properties.Connected {
return ErrNotConnected
}
if char == nil {
return ErrCharNotAvail
}
return nil
}