xiaomihome/xiaomi/devices/water_heater.go

package devices

import (
	"context"
	"xiaomihome/xiaomi"
)

// WaterHeater 热水器/饮水机统一控制接口
type WaterHeater interface {
	Device
	TurnOn(ctx context.Context) error
	TurnOff(ctx context.Context) error
	IsOn(ctx context.Context) (bool, error)
	SetTargetTemp(ctx context.Context, temp float64) error
	GetTargetTemp(ctx context.Context) (float64, error)
	GetCurrentTemp(ctx context.Context) (float64, error)

	OnStateChanged(handler func(state HeaterState, changed string)) (string, error)
	GetState() HeaterState
	FetchState(ctx context.Context) (HeaterState, error)
}

// HeaterState 热水器状态（MQTT 缓存）
type HeaterState struct {
	On          bool    `json:"on"`
	TargetTemp  float64 `json:"targetTemperature"`
	CurrentTemp float64 `json:"temperature"`
}

type waterHeaterDevice struct {
	BaseDevice
	propOn          siidPiid
	propTargetTemp  siidPiid
	propCurrentTemp siidPiid
	stateCache      HeaterState
}

func NewWaterHeater(client *xiaomi.Client, info *xiaomi.DeviceInfo) (WaterHeater, error) {
	d := &waterHeaterDevice{BaseDevice: NewBaseDevice(client, info)}
	resolver := d.getSpecResolver()
	if resolver == nil { return nil, xiaomi.ErrNoSPEC }
	siid, piid, ok := resolver.find("on")
	if !ok { return nil, xiaomi.ErrNotSupported }
	d.propOn = siidPiid{siid, piid, true}
	if s, p, ok := resolver.find("target-temperature"); ok { d.propTargetTemp = siidPiid{s, p, true} }
	if s, p, ok := resolver.find("temperature"); ok { d.propCurrentTemp = siidPiid{s, p, true} }
	return d, nil
}

func (d *waterHeaterDevice) TurnOn(ctx context.Context) error {
	if !d.propOn.valid { return xiaomi.ErrNotSupported }
	return d.SetProp(ctx, d.propOn.siid, d.propOn.piid, true)
}
func (d *waterHeaterDevice) TurnOff(ctx context.Context) error {
	if !d.propOn.valid { return xiaomi.ErrNotSupported }
	return d.SetProp(ctx, d.propOn.siid, d.propOn.piid, false)
}
func (d *waterHeaterDevice) IsOn(ctx context.Context) (bool, error) {
	if !d.propOn.valid { return false, xiaomi.ErrNotSupported }
	prop, err := d.GetProp(ctx, d.propOn.siid, d.propOn.piid)
	if err != nil { return false, err }
	if b, ok := prop.Value.(bool); ok { return b, nil }
	return false, nil
}
func (d *waterHeaterDevice) SetTargetTemp(ctx context.Context, temp float64) error {
	if !d.propTargetTemp.valid { return xiaomi.ErrNotSupported }
	return d.SetProp(ctx, d.propTargetTemp.siid, d.propTargetTemp.piid, temp)
}
func (d *waterHeaterDevice) GetTargetTemp(ctx context.Context) (float64, error) {
	if !d.propTargetTemp.valid { return 0, xiaomi.ErrNotSupported }
	prop, err := d.GetProp(ctx, d.propTargetTemp.siid, d.propTargetTemp.piid)
	if err != nil { return 0, err }
	return toFloat(prop.Value), nil
}
func (d *waterHeaterDevice) GetCurrentTemp(ctx context.Context) (float64, error) {
	if !d.propCurrentTemp.valid { return 0, xiaomi.ErrNotSupported }
	prop, err := d.GetProp(ctx, d.propCurrentTemp.siid, d.propCurrentTemp.piid)
	if err != nil { return 0, err }
	return toFloat(prop.Value), nil
}

func (d *waterHeaterDevice) OnStateChanged(handler func(state HeaterState, changed string)) (string, error) {
	type field struct{ siid, piid int; name string; fill func(*HeaterState, interface{}) }
	var fields []field
	if d.propOn.valid {
		fields = append(fields, field{d.propOn.siid, d.propOn.piid, "on", func(s *HeaterState, v interface{}) { s.On, _ = v.(bool) }})
	}
	if d.propTargetTemp.valid {
		fields = append(fields, field{d.propTargetTemp.siid, d.propTargetTemp.piid, "target-temperature", func(s *HeaterState, v interface{}) { s.TargetTemp = toFloat(v) }})
	}
	if d.propCurrentTemp.valid {
		fields = append(fields, field{d.propCurrentTemp.siid, d.propCurrentTemp.piid, "temperature", func(s *HeaterState, v interface{}) { s.CurrentTemp = toFloat(v) }})
	}
	if len(fields) == 0 { return "", xiaomi.ErrNotSupported }
	return d.SubProp(0, 0, func(did string, prop *xiaomi.PropertyValue) {
		for _, f := range fields {
			if f.siid == prop.SIID && f.piid == prop.PIID {
				f.fill(&d.stateCache, prop.Value)
				handler(d.stateCache, f.name)
				return
			}
		}
	})
}

func (d *waterHeaterDevice) GetState() HeaterState { return d.stateCache }
func (d *waterHeaterDevice) FetchState(ctx context.Context) (HeaterState, error) {
	keys := []xiaomi.PropKey{}
	if d.propOn.valid { keys = append(keys, xiaomi.PropKey{DID: d.info.DID, SIID: d.propOn.siid, PIID: d.propOn.piid}) }
	if d.propTargetTemp.valid { keys = append(keys, xiaomi.PropKey{DID: d.info.DID, SIID: d.propTargetTemp.siid, PIID: d.propTargetTemp.piid}) }
	if d.propCurrentTemp.valid { keys = append(keys, xiaomi.PropKey{DID: d.info.DID, SIID: d.propCurrentTemp.siid, PIID: d.propCurrentTemp.piid}) }
	props, err := d.client.GetProps(ctx, keys)
	if err != nil { return d.stateCache, err }
	state := HeaterState{}
	for _, p := range props {
		switch {
		case d.propOn.valid && p.SIID == d.propOn.siid && p.PIID == d.propOn.piid: state.On, _ = p.Value.(bool)
		case d.propTargetTemp.valid && p.SIID == d.propTargetTemp.siid && p.PIID == d.propTargetTemp.piid: state.TargetTemp = toFloat(p.Value)
		case d.propCurrentTemp.valid && p.SIID == d.propCurrentTemp.siid && p.PIID == d.propCurrentTemp.piid: state.CurrentTemp = toFloat(p.Value)
		}
	}
	d.stateCache = state
	return state, nil
}