4566704
8ffc9e4e44
按照 TOKEN_REFACTOR.md / FIX_CONFIG.md 方案重构核心层： - miot: Init() 优先读 storage token，新增 RefreshAuthInfo() 和刷新回调 - xiaomi: Config 改用 AuthInfo 结构体（含 UUID/UID/DataDir/OnTokenRefreshed） - xiaomi: NewClient(ctx, Config) 新签名，新增 RefreshToken()，后台自动刷新 - xiaomi/devices: 设备控制接口重构 - 新增示例 12_ac_subscribe，其余示例适配新 Config
503 lines
14 KiB
Go
503 lines
14 KiB
Go
package devices
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
|
||
"xiaomihome/xiaomi"
|
||
)
|
||
|
||
// ========== 空调模式/风速/摆风常量 ==========
|
||
|
||
// ACMode 空调模式
|
||
type ACMode string
|
||
|
||
const (
|
||
ModeCool ACMode = "cool"
|
||
ModeHeat ACMode = "heat"
|
||
ModeFan ACMode = "fan"
|
||
ModeDry ACMode = "dry"
|
||
ModeAuto ACMode = "auto"
|
||
)
|
||
|
||
// modeValueMap 模式值映射（uint8 → ACMode）
|
||
var modeValueMap = map[int]ACMode{
|
||
0: ModeCool,
|
||
1: ModeHeat,
|
||
2: ModeFan,
|
||
3: ModeDry,
|
||
4: ModeAuto,
|
||
}
|
||
|
||
var modeReverseMap = map[ACMode]int{
|
||
ModeCool: 0,
|
||
ModeHeat: 1,
|
||
ModeFan: 2,
|
||
ModeDry: 3,
|
||
ModeAuto: 4,
|
||
}
|
||
|
||
// FanSpeed 风速
|
||
type FanSpeed string
|
||
|
||
const (
|
||
SpeedLow FanSpeed = "low"
|
||
SpeedMedium FanSpeed = "medium"
|
||
SpeedHigh FanSpeed = "high"
|
||
SpeedAuto FanSpeed = "auto"
|
||
)
|
||
|
||
var fanSpeedValueMap = map[int]FanSpeed{
|
||
0: SpeedLow,
|
||
1: SpeedMedium,
|
||
2: SpeedHigh,
|
||
3: SpeedAuto,
|
||
}
|
||
|
||
var fanSpeedReverseMap = map[FanSpeed]int{
|
||
SpeedLow: 0,
|
||
SpeedMedium: 1,
|
||
SpeedHigh: 2,
|
||
SpeedAuto: 3,
|
||
}
|
||
|
||
// SwingMode 摆风模式
|
||
type SwingMode string
|
||
|
||
const (
|
||
SwingOff SwingMode = "off"
|
||
SwingVertical SwingMode = "vertical"
|
||
SwingHorizontal SwingMode = "horizontal"
|
||
SwingBoth SwingMode = "both"
|
||
)
|
||
|
||
var swingValueMap = map[int]SwingMode{
|
||
0: SwingOff,
|
||
1: SwingVertical,
|
||
2: SwingHorizontal,
|
||
3: SwingBoth,
|
||
}
|
||
|
||
var swingReverseMap = map[SwingMode]int{
|
||
SwingOff: 0,
|
||
SwingVertical: 1,
|
||
SwingHorizontal: 2,
|
||
SwingBoth: 3,
|
||
}
|
||
|
||
// ========== AirConditioner 接口 ==========
|
||
|
||
// AirConditioner 空调统一控制接口
|
||
type AirConditioner interface {
|
||
Device
|
||
TurnOn(ctx context.Context) error
|
||
TurnOff(ctx context.Context) error
|
||
IsOn(ctx context.Context) (bool, error)
|
||
|
||
// 能力查询
|
||
HasFanSpeed() bool
|
||
HasSwing() bool
|
||
HasHumidity() bool
|
||
HasAuxHeat() bool
|
||
HasEco() bool
|
||
|
||
// 模式控制
|
||
SetMode(ctx context.Context, mode ACMode) error
|
||
GetMode(ctx context.Context) (ACMode, error)
|
||
|
||
// 温度控制
|
||
SetTargetTemp(ctx context.Context, celsius float64) error
|
||
GetTargetTemp(ctx context.Context) (float64, error)
|
||
GetCurrentTemp(ctx context.Context) (float64, error) // 室内温度
|
||
|
||
// 风速控制
|
||
SetFanSpeed(ctx context.Context, speed FanSpeed) error
|
||
GetFanSpeed(ctx context.Context) (FanSpeed, error)
|
||
|
||
// 摆风控制
|
||
SetSwing(ctx context.Context, mode SwingMode) error
|
||
GetSwing(ctx context.Context) (SwingMode, error)
|
||
|
||
// 湿度
|
||
SetTargetHumidity(ctx context.Context, pct int) error
|
||
GetTargetHumidity(ctx context.Context) (int, error)
|
||
GetCurrentHumidity(ctx context.Context) (int, error)
|
||
|
||
// 电辅热
|
||
SetAuxHeat(ctx context.Context, on bool) error
|
||
GetAuxHeat(ctx context.Context) (bool, error)
|
||
|
||
// 节能
|
||
SetEco(ctx context.Context, on bool) error
|
||
GetEco(ctx context.Context) (bool, error)
|
||
|
||
// 订阅
|
||
OnStateChanged(handler func(state ACState, changed string)) (string, error)
|
||
}
|
||
|
||
// ACState 空调完整状态（字段名对齐 SPEC type）
|
||
type ACState struct {
|
||
On bool `json:"on"` // SPEC: "on"
|
||
Mode ACMode `json:"mode"` // SPEC: "mode"
|
||
TargetTemperature float64 `json:"targetTemperature"` // SPEC: "target-temperature"
|
||
Temperature float64 `json:"temperature"` // SPEC: "temperature" (当前温度)
|
||
TargetHumidity int `json:"targetHumidity"` // SPEC: "target-humidity"
|
||
CurrentHumidity int `json:"currentHumidity"` // SPEC: "relative-humidity"
|
||
FanLevel FanSpeed `json:"fanLevel"` // SPEC: "fan-level"
|
||
Swing SwingMode `json:"swing"` // SPEC: "swing"
|
||
AuxHeat bool `json:"auxHeat"` // SPEC: "heater"
|
||
Eco bool `json:"eco"` // SPEC: "eco"
|
||
}
|
||
|
||
type acDevice struct {
|
||
BaseDevice
|
||
propOn siidPiid // "on"
|
||
propMode siidPiid // "mode"
|
||
propTargetTemp siidPiid // "target-temperature"
|
||
propCurrentTemp siidPiid // "temperature"
|
||
propFanSpeed siidPiid // "fan-level"
|
||
propSwing siidPiid // "swing-mode" or "horizontal-swing" or "vertical-swing"
|
||
propTargetHumidity siidPiid // "target-humidity"
|
||
propCurrentHumidity siidPiid // "relative-humidity"
|
||
propAuxHeat siidPiid // "aux-heat" or "heater"
|
||
propEco siidPiid // "eco"
|
||
|
||
stateCache ACState // MQTT 推送维护的本地缓存
|
||
}
|
||
|
||
// NewAirConditioner creates an AirConditioner control for the given device.
|
||
func NewAirConditioner(client *xiaomi.Client, info *xiaomi.DeviceInfo) (AirConditioner, error) {
|
||
d := &acDevice{
|
||
BaseDevice: NewBaseDevice(client, info),
|
||
}
|
||
|
||
resolver := d.getSpecResolver()
|
||
if resolver == nil {
|
||
return nil, xiaomi.ErrNoSPEC
|
||
}
|
||
|
||
// "on" is required
|
||
siid, piid, ok := resolver.find("on")
|
||
if !ok {
|
||
return nil, xiaomi.ErrNotSupported
|
||
}
|
||
d.propOn = siidPiid{siid, piid, true}
|
||
|
||
// Optional properties — each independently resolved
|
||
if s, p, ok := resolver.find("mode"); ok {
|
||
d.propMode = siidPiid{s, p, 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}
|
||
}
|
||
if s, p, ok := resolver.find("fan-level"); ok {
|
||
d.propFanSpeed = siidPiid{s, p, true}
|
||
}
|
||
// Try multiple swing mode type names
|
||
if s, p, ok := resolver.find("swing-mode"); ok {
|
||
d.propSwing = siidPiid{s, p, true}
|
||
} else if s, p, ok := resolver.find("horizontal-swing"); ok {
|
||
d.propSwing = siidPiid{s, p, true}
|
||
} else if s, p, ok := resolver.find("vertical-swing"); ok {
|
||
d.propSwing = siidPiid{s, p, true}
|
||
}
|
||
if s, p, ok := resolver.find("target-humidity"); ok {
|
||
d.propTargetHumidity = siidPiid{s, p, true}
|
||
}
|
||
if s, p, ok := resolver.find("relative-humidity"); ok {
|
||
d.propCurrentHumidity = siidPiid{s, p, true}
|
||
}
|
||
if s, p, ok := resolver.find("heater"); ok {
|
||
d.propAuxHeat = siidPiid{s, p, true}
|
||
} else if s, p, ok := resolver.find("aux-heat"); ok {
|
||
d.propAuxHeat = siidPiid{s, p, true}
|
||
}
|
||
if s, p, ok := resolver.find("eco"); ok {
|
||
d.propEco = siidPiid{s, p, true}
|
||
}
|
||
|
||
return d, nil
|
||
}
|
||
|
||
func (d *acDevice) 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 *acDevice) 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 *acDevice) 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 *acDevice) HasFanSpeed() bool { return d.propFanSpeed.valid }
|
||
func (d *acDevice) HasSwing() bool { return d.propSwing.valid }
|
||
func (d *acDevice) HasHumidity() bool { return d.propTargetHumidity.valid }
|
||
func (d *acDevice) HasAuxHeat() bool { return d.propAuxHeat.valid }
|
||
func (d *acDevice) HasEco() bool { return d.propEco.valid }
|
||
|
||
func (d *acDevice) SetMode(ctx context.Context, mode ACMode) error {
|
||
if !d.propMode.valid {
|
||
return xiaomi.ErrNotSupported
|
||
}
|
||
val, ok := modeReverseMap[mode]
|
||
if !ok {
|
||
val = 4 // default auto
|
||
}
|
||
return d.SetProp(ctx, d.propMode.siid, d.propMode.piid, val)
|
||
}
|
||
|
||
func (d *acDevice) GetMode(ctx context.Context) (ACMode, error) {
|
||
if !d.propMode.valid {
|
||
return ModeAuto, xiaomi.ErrNotSupported
|
||
}
|
||
prop, err := d.GetProp(ctx, d.propMode.siid, d.propMode.piid)
|
||
if err != nil {
|
||
return ModeAuto, err
|
||
}
|
||
v := toInt(prop.Value)
|
||
if m, ok := modeValueMap[v]; ok {
|
||
return m, nil
|
||
}
|
||
return ModeAuto, nil
|
||
}
|
||
|
||
func (d *acDevice) SetTargetTemp(ctx context.Context, celsius float64) error {
|
||
if !d.propTargetTemp.valid {
|
||
return xiaomi.ErrNotSupported
|
||
}
|
||
return d.SetProp(ctx, d.propTargetTemp.siid, d.propTargetTemp.piid, celsius)
|
||
}
|
||
|
||
func (d *acDevice) 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 *acDevice) 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 *acDevice) SetFanSpeed(ctx context.Context, speed FanSpeed) error {
|
||
if !d.propFanSpeed.valid {
|
||
return xiaomi.ErrNotSupported
|
||
}
|
||
val, ok := fanSpeedReverseMap[speed]
|
||
if !ok {
|
||
val = 3 // default auto
|
||
}
|
||
return d.SetProp(ctx, d.propFanSpeed.siid, d.propFanSpeed.piid, val)
|
||
}
|
||
|
||
func (d *acDevice) GetFanSpeed(ctx context.Context) (FanSpeed, error) {
|
||
if !d.propFanSpeed.valid {
|
||
return SpeedAuto, xiaomi.ErrNotSupported
|
||
}
|
||
prop, err := d.GetProp(ctx, d.propFanSpeed.siid, d.propFanSpeed.piid)
|
||
if err != nil {
|
||
return SpeedAuto, err
|
||
}
|
||
v := toInt(prop.Value)
|
||
if s, ok := fanSpeedValueMap[v]; ok {
|
||
return s, nil
|
||
}
|
||
return SpeedAuto, nil
|
||
}
|
||
|
||
func (d *acDevice) SetSwing(ctx context.Context, mode SwingMode) error {
|
||
if !d.propSwing.valid {
|
||
return xiaomi.ErrNotSupported
|
||
}
|
||
val, ok := swingReverseMap[mode]
|
||
if !ok {
|
||
val = 0
|
||
}
|
||
return d.SetProp(ctx, d.propSwing.siid, d.propSwing.piid, val)
|
||
}
|
||
|
||
func (d *acDevice) GetSwing(ctx context.Context) (SwingMode, error) {
|
||
if !d.propSwing.valid {
|
||
return SwingOff, xiaomi.ErrNotSupported
|
||
}
|
||
prop, err := d.GetProp(ctx, d.propSwing.siid, d.propSwing.piid)
|
||
if err != nil {
|
||
return SwingOff, err
|
||
}
|
||
v := toInt(prop.Value)
|
||
if s, ok := swingValueMap[v]; ok {
|
||
return s, nil
|
||
}
|
||
return SwingOff, nil
|
||
}
|
||
|
||
func (d *acDevice) SetTargetHumidity(ctx context.Context, pct int) error {
|
||
if !d.propTargetHumidity.valid {
|
||
return xiaomi.ErrNotSupported
|
||
}
|
||
return d.SetProp(ctx, d.propTargetHumidity.siid, d.propTargetHumidity.piid, pct)
|
||
}
|
||
|
||
func (d *acDevice) GetTargetHumidity(ctx context.Context) (int, error) {
|
||
if !d.propTargetHumidity.valid {
|
||
return 0, xiaomi.ErrNotSupported
|
||
}
|
||
prop, err := d.GetProp(ctx, d.propTargetHumidity.siid, d.propTargetHumidity.piid)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return toInt(prop.Value), nil
|
||
}
|
||
|
||
func (d *acDevice) GetCurrentHumidity(ctx context.Context) (int, error) {
|
||
if !d.propCurrentHumidity.valid {
|
||
return 0, xiaomi.ErrNotSupported
|
||
}
|
||
prop, err := d.GetProp(ctx, d.propCurrentHumidity.siid, d.propCurrentHumidity.piid)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return toInt(prop.Value), nil
|
||
}
|
||
|
||
func (d *acDevice) SetAuxHeat(ctx context.Context, on bool) error {
|
||
if !d.propAuxHeat.valid {
|
||
return xiaomi.ErrNotSupported
|
||
}
|
||
return d.SetProp(ctx, d.propAuxHeat.siid, d.propAuxHeat.piid, on)
|
||
}
|
||
|
||
func (d *acDevice) GetAuxHeat(ctx context.Context) (bool, error) {
|
||
if !d.propAuxHeat.valid {
|
||
return false, xiaomi.ErrNotSupported
|
||
}
|
||
prop, err := d.GetProp(ctx, d.propAuxHeat.siid, d.propAuxHeat.piid)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if b, ok := prop.Value.(bool); ok {
|
||
return b, nil
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
func (d *acDevice) SetEco(ctx context.Context, on bool) error {
|
||
if !d.propEco.valid {
|
||
return xiaomi.ErrNotSupported
|
||
}
|
||
return d.SetProp(ctx, d.propEco.siid, d.propEco.piid, on)
|
||
}
|
||
|
||
func (d *acDevice) GetEco(ctx context.Context) (bool, error) {
|
||
if !d.propEco.valid {
|
||
return false, xiaomi.ErrNotSupported
|
||
}
|
||
prop, err := d.GetProp(ctx, d.propEco.siid, d.propEco.piid)
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if b, ok := prop.Value.(bool); ok {
|
||
return b, nil
|
||
}
|
||
return false, nil
|
||
}
|
||
|
||
// propField maps a SPEC short name to a siid/piid pair and a cache-update function.
|
||
type propField struct {
|
||
siid, piid int
|
||
name string
|
||
fill func(*ACState, interface{})
|
||
}
|
||
|
||
func (d *acDevice) OnStateChanged(handler func(state ACState, changed string)) (string, error) {
|
||
fields := d.propFields()
|
||
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 *acDevice) propFields() []propField {
|
||
var fields []propField
|
||
add := func(sp siidPiid, name string, fill func(*ACState, interface{})) {
|
||
if sp.valid {
|
||
fields = append(fields, propField{sp.siid, sp.piid, name, fill})
|
||
}
|
||
}
|
||
add(d.propOn, "on", func(s *ACState, v interface{}) { s.On, _ = v.(bool) })
|
||
add(d.propMode, "mode", func(s *ACState, v interface{}) {
|
||
switch m := v.(type) {
|
||
case string: s.Mode = ACMode(m)
|
||
case float64: s.Mode = ACMode(fmt.Sprintf("%.0f", m))
|
||
}
|
||
})
|
||
add(d.propTargetTemp, "target-temperature", func(s *ACState, v interface{}) { s.TargetTemperature = toFloat(v) })
|
||
add(d.propCurrentTemp, "temperature", func(s *ACState, v interface{}) { s.Temperature = toFloat(v) })
|
||
add(d.propFanSpeed, "fan-level", func(s *ACState, v interface{}) {
|
||
if v, ok := v.(float64); ok { s.FanLevel = FanSpeed(fmt.Sprintf("%.0f", v)) }
|
||
})
|
||
add(d.propSwing, "swing", func(s *ACState, v interface{}) {
|
||
if v, ok := v.(float64); ok { s.Swing = SwingMode(fmt.Sprintf("%.0f", v)) }
|
||
})
|
||
add(d.propTargetHumidity, "target-humidity", func(s *ACState, v interface{}) { s.TargetHumidity = int(toFloat(v)) })
|
||
add(d.propCurrentHumidity, "relative-humidity", func(s *ACState, v interface{}) { s.CurrentHumidity = int(toFloat(v)) })
|
||
add(d.propAuxHeat, "heater", func(s *ACState, v interface{}) { s.AuxHeat, _ = v.(bool) })
|
||
add(d.propEco, "eco", func(s *ACState, v interface{}) { s.Eco, _ = v.(bool) })
|
||
return fields
|
||
}
|
||
|
||
// toFloat converts an interface{} to float64.
|
||
func toFloat(v interface{}) float64 {
|
||
switch n := v.(type) {
|
||
case float64:
|
||
return n
|
||
case float32:
|
||
return float64(n)
|
||
case int:
|
||
return float64(n)
|
||
case int64:
|
||
return float64(n)
|
||
}
|
||
return 0
|
||
}
|