func (d *Device) SetPower(state bool) error {
p := &payloadPower{}
if state {
p.Level = math.MaxUint16
}
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(SetPower)
if err := pkt.SetPayload(p); err != nil {
return err
}
common.Log.Debugf("Setting power state on %d: %v", d.id, state)
req, err := d.Send(pkt, d.reliable, false)
if err != nil {
return err
}
if d.reliable {
// Wait for ack
<-req
common.Log.Debugf("Setting power state on %d acknowledged", d.id)
}
d.Lock()
d.power = p.Level
d.Unlock()
return d.publish(common.EventUpdatePower{Power: p.Level > 0})
}
func (l *Light) SetColor(color common.Color, duration time.Duration) error {
if l.color == color {
return nil
}
if duration < shared.RateLimit {
duration = shared.RateLimit
}
p := &payloadColor{
Color: color,
Duration: uint32(duration / time.Millisecond),
}
pkt := packet.New(l.address, l.requestSocket)
pkt.SetType(SetColor)
if err := pkt.SetPayload(p); err != nil {
return err
}
req, err := l.Send(pkt, l.reliable, false)
if err != nil {
return err
}
if l.reliable {
// Wait for ack
<-req
common.Log.Debugf("Setting color on %v acknowledged\n", l.id)
}
l.color = color
if err := l.publish(common.EventUpdateColor{Color: l.color}); err != nil {
return err
}
return nil
}
func (l *Light) SetPowerDuration(state bool, duration time.Duration) error {
p := new(payloadPowerDuration)
if state {
p.Level = math.MaxUint16
}
p.Duration = uint32(duration / time.Millisecond)
pkt := packet.New(l.address, l.requestSocket)
pkt.SetType(LightSetPower)
if err := pkt.SetPayload(p); err != nil {
return err
}
common.Log.Debugf("Setting power state on %d: %v", l.id, state)
req, err := l.Send(pkt, l.reliable, false)
if err != nil {
return err
}
if l.reliable {
// Wait for ack
<-req
common.Log.Debugf("Setting power state on %d acknowledged", l.id)
}
l.Lock()
l.power = p.Level
l.Unlock()
return l.publish(common.EventUpdatePower{Power: l.power > 0})
}
func (d *Device) GetHardwareVersion() (uint32, error) {
if d.CachedHardwareProduct() != 0 {
return d.CachedHardwareVersion(), nil
}
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(GetVersion)
req, err := d.Send(pkt, d.reliable, true)
if err != nil {
return 0, err
}
common.Log.Debugf("Waiting for hardware version (%d)", d.id)
pktResponse := <-req
if pktResponse.Error != nil {
return 0, err
}
v := stateVersion{}
if err = pktResponse.Result.DecodePayload(&v); err != nil {
return 0, err
}
common.Log.Debugf("Got hardware version (%d): %+v", d.id, v)
d.Lock()
d.hardwareVersion = v
d.Unlock()
return d.CachedHardwareVersion(), nil
}
func (d *Device) SetLabel(label string) error {
if d.CachedLabel() == label {
return nil
}
p := &payloadLabel{}
copy(p.Label[:], label)
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(SetLabel)
if err := pkt.SetPayload(p); err != nil {
return err
}
common.Log.Debugf("Setting label on %d: %s", d.id, label)
req, err := d.Send(pkt, d.reliable, false)
if err != nil {
return err
}
if d.reliable {
// Wait for ack
<-req
common.Log.Debugf("Setting label on %d acknowledged", d.id)
}
d.Lock()
d.label = label
d.Unlock()
return d.publish(common.EventUpdateLabel{Label: label})
}
func (d *Device) GetLabel() (string, error) {
label := d.CachedLabel()
if len(label) != 0 {
return label, nil
}
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(GetLabel)
req, err := d.Send(pkt, d.reliable, true)
if err != nil {
return ``, err
}
common.Log.Debugf("Waiting for label (%d)", d.id)
pktResponse := <-req
if pktResponse.Error != nil {
return ``, err
}
err = d.SetStateLabel(pktResponse.Result)
if err != nil {
return ``, err
}
return d.CachedLabel(), nil
}
func (d *Device) GetHardwareVersion() (uint32, error) {
if d.hardwareVersion.Product != 0 {
return d.hardwareVersion.Version, nil
}
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(GetVersion)
req, err := d.Send(pkt, d.reliable, true)
if err != nil {
return 0, err
}
common.Log.Debugf("Waiting for hardware version (%v)\n", d.id)
pktResponse := <-req
if pktResponse.Error != nil {
return 0, err
}
if err = pktResponse.Result.DecodePayload(&d.hardwareVersion); err != nil {
return 0, err
}
common.Log.Debugf("Got hardware version (%v): %+v\n", d.id, d.hardwareVersion)
return d.hardwareVersion.Version, nil
}
func (d *Device) GetGroup() (ret string, err error) {
if d.groupID != ret {
return d.groupID, nil
}
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(GetGroup)
req, err := d.Send(pkt, d.reliable, true)
if err != nil {
return ret, err
}
common.Log.Debugf("Waiting for group (%v)\n", d.id)
pktResponse := <-req
if pktResponse.Error != nil {
return ret, err
}
err = d.SetStateGroup(&pktResponse.Result)
if err != nil {
return ret, err
}
return d.groupID, nil
}
func (d *Device) SetPower(state bool) error {
if state && d.power > 0 {
return nil
}
p := new(payloadPower)
if state {
p.Level = math.MaxUint16
}
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(SetPower)
if err := pkt.SetPayload(p); err != nil {
return err
}
common.Log.Debugf("Setting power state on %v: %v\n", d.id, state)
req, err := d.Send(pkt, d.reliable, false)
if err != nil {
return err
}
if d.reliable {
// Wait for ack
<-req
common.Log.Debugf("Setting power state on %v acknowledged\n", d.id)
}
d.power = p.Level
if err := d.publish(common.EventUpdatePower{Power: d.power > 0}); err != nil {
return err
}
return nil
}
func (d *Device) Discover() error {
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(GetService)
_, err := d.Send(pkt, false, false)
if err != nil {
return err
}
return nil
}
func (l *Light) Get() error {
pkt := packet.New(l.address, l.requestSocket)
pkt.SetType(Get)
req, err := l.Send(pkt, l.reliable, true)
if err != nil {
return err
}
common.Log.Debugf("Waiting for light state (%d)", l.id)
pktResponse := <-req
if pktResponse.Error != nil {
return pktResponse.Error
}
return l.SetState(pktResponse.Result)
}
func (d *Device) GetFirmwareVersion() (ret string, err error) {
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(GetHostFirmware)
req, err := d.Send(pkt, d.reliable, true)
if err != nil {
return ret, err
}
common.Log.Debugf("Waiting for firmware data (%d)", d.id)
pktResponse := <-req
if pktResponse.Error != nil {
return ret, err
}
err = d.SetStateHostFirmware(pktResponse.Result)
if err != nil {
return ret, err
}
return d.CachedFirmwareVersion(), nil
}
func (d *Device) GetPower() (bool, error) {
pkt := packet.New(d.address, d.requestSocket)
pkt.SetType(GetPower)
req, err := d.Send(pkt, d.reliable, true)
if err != nil {
return false, err
}
common.Log.Debugf("Waiting for power (%d)", d.id)
pktResponse := <-req
if pktResponse.Error != nil {
return false, err
}
err = d.SetStatePower(pktResponse.Result)
if err != nil {
return false, err
}
return d.CachedPower(), nil
}
